Add FromVolumeFile time dependent option

src/Domain/Creators/BinaryCompactObject.cpp

@@ -32,9 +32,9 @@
 #include "Domain/CoordinateMaps/ProductMaps.hpp"
 #include "Domain/CoordinateMaps/ProductMaps.tpp"
 #include "Domain/CoordinateMaps/Wedge.hpp"
-#include "Domain/Creators/BinaryCompactObjectHelpers.hpp"
 #include "Domain/Creators/DomainCreator.hpp"  // IWYU pragma: keep
 #include "Domain/Creators/ExpandOverBlocks.hpp"
+#include "Domain/Creators/TimeDependentOptions/BinaryCompactObject.hpp"
 #include "Domain/Domain.hpp"
 #include "Domain/DomainHelpers.hpp"
 #include "Domain/ExcisionSphere.hpp"
@@ -50,6 +50,20 @@ struct BlockLogical;
 }  // namespace Frame
 
 namespace domain::creators {
+namespace bco {
+std::unordered_map<std::string, tnsr::I<double, 3, Frame::Grid>>
+create_grid_anchors(const std::array<double, 3>& center_a,
+                    const std::array<double, 3>& center_b) {
+  std::unordered_map<std::string, tnsr::I<double, 3, Frame::Grid>> result{};
+  result["Center" + get_output(ObjectLabel::A)] =
+      tnsr::I<double, 3, Frame::Grid>{center_a};
+  result["Center" + get_output(ObjectLabel::B)] =
+      tnsr::I<double, 3, Frame::Grid>{center_b};
+  result["Center"] = tnsr::I<double, 3, Frame::Grid>{std::array{0.0, 0.0, 0.0}};
+
+  return result;
+}
+}  // namespace bco
 
 bool BinaryCompactObject::Object::is_excised() const {
   return inner_boundary_condition.has_value();
@@ -261,7 +275,7 @@ BinaryCompactObject::BinaryCompactObject(
     add_object_region("ObjectB", "Cube");   // 6 blocks
     first_outer_shell_block_ += 12;
   }
-  add_outer_region("Envelope");    // 10 blocks
+  add_outer_region("Envelope");  // 10 blocks
   first_outer_shell_block_ += 10;
   add_outer_region("OuterShell");  // 10 blocks
 

src/Domain/Creators/BinaryCompactObject.hpp

@@ -20,8 +20,8 @@
 #include "Domain/BoundaryConditions/GetBoundaryConditionsBase.hpp"
 #include "Domain/CoordinateMaps/CoordinateMap.hpp"
 #include "Domain/CoordinateMaps/Distribution.hpp"
-#include "Domain/Creators/BinaryCompactObjectHelpers.hpp"
 #include "Domain/Creators/DomainCreator.hpp"
+#include "Domain/Creators/TimeDependentOptions/BinaryCompactObject.hpp"
 #include "Domain/Domain.hpp"
 #include "Domain/Structure/DirectionMap.hpp"
 #include "Options/Auto.hpp"
@@ -66,6 +66,22 @@ struct BlockLogical;
 
 namespace domain {
 namespace creators {
+namespace bco {
+/*!
+ * \brief Create a set of centers of objects for the binary domains.
+ *
+ * \details Will add the following centers to the set:
+ *
+ * - Center: The origin
+ * - CenterA: Center of object A
+ * - CenterB: Center of object B
+ *
+ * \return Object required by the DomainCreator%s
+ */
+std::unordered_map<std::string, tnsr::I<double, 3, Frame::Grid>>
+create_grid_anchors(const std::array<double, 3>& center_a,
+                    const std::array<double, 3>& center_b);
+}  // namespace bco
 
 /*!
  * \ingroup ComputationalDomainGroup

src/Domain/Creators/CMakeLists.txt

@@ -10,7 +10,6 @@ spectre_target_sources(
   PRIVATE
   AlignedLattice.cpp
   BinaryCompactObject.cpp
-  BinaryCompactObjectHelpers.cpp
   BlockGroups.cpp
   Brick.cpp
   Cylinder.cpp
@@ -24,9 +23,7 @@ spectre_target_sources(
   RotatedBricks.cpp
   RotatedIntervals.cpp
   RotatedRectangles.cpp
-  ShapeMapOptions.cpp
   Sphere.cpp
-  SphereTimeDependentMaps.cpp
   )
 
 spectre_target_headers(
@@ -35,7 +32,6 @@ spectre_target_headers(
   HEADERS
   AlignedLattice.hpp
   BinaryCompactObject.hpp
-  BinaryCompactObjectHelpers.hpp
   BlockGroups.hpp
   Brick.hpp
   Cylinder.hpp
@@ -56,15 +52,14 @@ spectre_target_headers(
   RotatedBricks.hpp
   RotatedIntervals.hpp
   RotatedRectangles.hpp
-  ShapeMapOptions.hpp
   Sphere.hpp
-  SphereTimeDependentMaps.hpp
   )
 
 target_link_libraries(
   ${LIBRARY}
   PRIVATE
   DomainStructure
+  H5
   PUBLIC
   CoordinateMaps
   DataStructures
@@ -82,3 +77,4 @@ target_link_libraries(
 add_subdirectory(Python)
 add_subdirectory(Tags)
 add_subdirectory(TimeDependence)
+add_subdirectory(TimeDependentOptions)

src/Domain/Creators/CylindricalBinaryCompactObject.cpp

@@ -20,8 +20,9 @@
 #include "Domain/CoordinateMaps/UniformCylindricalFlatEndcap.hpp"
 #include "Domain/CoordinateMaps/UniformCylindricalSide.hpp"
 #include "Domain/CoordinateMaps/Wedge.hpp"
-#include "Domain/Creators/BinaryCompactObjectHelpers.hpp"
+#include "Domain/Creators/BinaryCompactObject.hpp"
 #include "Domain/Creators/ExpandOverBlocks.hpp"
+#include "Domain/Creators/TimeDependentOptions/BinaryCompactObject.hpp"
 #include "Domain/DomainHelpers.hpp"
 #include "Domain/ExcisionSphere.hpp"
 #include "Domain/FunctionsOfTime/FixedSpeedCubic.hpp"

src/Domain/Creators/CylindricalBinaryCompactObject.hpp

@@ -16,8 +16,8 @@
 #include "Domain/BoundaryConditions/BoundaryCondition.hpp"
 #include "Domain/BoundaryConditions/GetBoundaryConditionsBase.hpp"
 #include "Domain/CoordinateMaps/CoordinateMap.hpp"
-#include "Domain/Creators/BinaryCompactObjectHelpers.hpp"
 #include "Domain/Creators/DomainCreator.hpp"
+#include "Domain/Creators/TimeDependentOptions/BinaryCompactObject.hpp"
 #include "Domain/Domain.hpp"
 #include "Domain/Structure/DirectionMap.hpp"
 #include "Domain/Structure/ObjectLabel.hpp"

src/Domain/Creators/Sphere.hpp

@@ -16,8 +16,8 @@
 #include "Domain/BoundaryConditions/GetBoundaryConditionsBase.hpp"
 #include "Domain/CoordinateMaps/Distribution.hpp"
 #include "Domain/Creators/DomainCreator.hpp"
-#include "Domain/Creators/SphereTimeDependentMaps.hpp"
 #include "Domain/Creators/TimeDependence/TimeDependence.hpp"
+#include "Domain/Creators/TimeDependentOptions/Sphere.hpp"
 #include "Domain/Domain.hpp"
 #include "Domain/Structure/DirectionMap.hpp"
 #include "Options/Auto.hpp"

src/Domain/Creators/BinaryCompactObjectHelpers.cpp → src/Domain/Creators/TimeDependentOptions/BinaryCompactObject.cpp

@@ -1,7 +1,7 @@
 // Distributed under the MIT License.
 // See LICENSE.txt for details.
 
-#include "Domain/Creators/BinaryCompactObjectHelpers.hpp"
+#include "Domain/Creators/TimeDependentOptions/BinaryCompactObject.hpp"
 
 #include <array>
 #include <limits>
@@ -16,7 +16,7 @@
 #include "Domain/CoordinateMaps/TimeDependent/ShapeMapTransitionFunctions/ShapeMapTransitionFunction.hpp"
 #include "Domain/CoordinateMaps/TimeDependent/ShapeMapTransitionFunctions/SphereTransition.hpp"
 #include "Domain/CoordinateMaps/TimeDependent/ShapeMapTransitionFunctions/Wedge.hpp"
-#include "Domain/Creators/ShapeMapOptions.hpp"
+#include "Domain/Creators/TimeDependentOptions/ShapeMap.hpp"
 #include "Domain/FunctionsOfTime/FixedSpeedCubic.hpp"
 #include "Domain/FunctionsOfTime/FunctionOfTime.hpp"
 #include "Domain/FunctionsOfTime/PiecewisePolynomial.hpp"
@@ -31,37 +31,25 @@
 #include "Utilities/StdArrayHelpers.hpp"
 
 namespace domain::creators::bco {
-std::unordered_map<std::string, tnsr::I<double, 3, Frame::Grid>>
-create_grid_anchors(const std::array<double, 3>& center_a,
-                    const std::array<double, 3>& center_b) {
-  std::unordered_map<std::string, tnsr::I<double, 3, Frame::Grid>> result{};
-  result["Center" + get_output(ObjectLabel::A)] =
-      tnsr::I<double, 3, Frame::Grid>{center_a};
-  result["Center" + get_output(ObjectLabel::B)] =
-      tnsr::I<double, 3, Frame::Grid>{center_b};
-  result["Center"] = tnsr::I<double, 3, Frame::Grid>{std::array{0.0, 0.0, 0.0}};
-
-  return result;
-}
-
 template <bool IsCylindrical>
 TimeDependentMapOptions<IsCylindrical>::TimeDependentMapOptions(
     double initial_time,
     std::optional<ExpansionMapOptions> expansion_map_options,
-    std::optional<RotationMapOptions> rotation_options,
+    std::optional<RotationMapOptions> rotation_map_options,
     std::optional<TranslationMapOptions> translation_map_options,
     std::optional<ShapeMapOptions<domain::ObjectLabel::A>> shape_options_A,
     std::optional<ShapeMapOptions<domain::ObjectLabel::B>> shape_options_B,
     const Options::Context& context)
     : initial_time_(initial_time),
       expansion_map_options_(expansion_map_options),
-      rotation_options_(rotation_options),
-      translation_options_(translation_map_options),
+      rotation_map_options_(rotation_map_options),
+      translation_map_options_(translation_map_options),
       shape_options_A_(shape_options_A),
       shape_options_B_(shape_options_B) {
-  if (not(expansion_map_options_.has_value() or rotation_options_.has_value() or
-          translation_options_.has_value() or shape_options_A_.has_value() or
-          shape_options_B_.has_value())) {
+  if (not(expansion_map_options_.has_value() or
+          rotation_map_options_.has_value() or
+          translation_map_options_.has_value() or
+          shape_options_A_.has_value() or shape_options_B_.has_value())) {
     PARSE_ERROR(context,
                 "Time dependent map options were specified, but all options "
                 "were 'None'. If you don't want time dependent maps, specify "
@@ -136,37 +124,40 @@ TimeDependentMapOptions<IsCylindrical>::create_functions_of_time(
   // (omega) to determine map parameters. In theory we could determine
   // each initial angle from the input axis-angle representation, but
   // we don't need to.
-  if (rotation_options_.has_value()) {
+  if (rotation_map_options_.has_value()) {
     result[rotation_name] = std::make_unique<
         FunctionsOfTime::QuaternionFunctionOfTime<3>>(
         initial_time_,
         std::array<DataVector, 1>{DataVector{1.0, 0.0, 0.0, 0.0}},
         std::array<DataVector, 4>{
             {{3, 0.0},
-             {gsl::at(rotation_options_.value().initial_angular_velocity, 0),
-              gsl::at(rotation_options_.value().initial_angular_velocity, 1),
-              gsl::at(rotation_options_.value().initial_angular_velocity, 2)},
+             {gsl::at(rotation_map_options_.value().initial_angular_velocity,
+                      0),
+              gsl::at(rotation_map_options_.value().initial_angular_velocity,
+                      1),
+              gsl::at(rotation_map_options_.value().initial_angular_velocity,
+                      2)},
              {3, 0.0},
              {3, 0.0}}},
         expiration_times.at(rotation_name));
   }
 
   // TranslationMap FunctionOfTime
-  if (translation_options_.has_value()) {
-    result[translation_name] =
-        std::make_unique<FunctionsOfTime::PiecewisePolynomial<2>>(
-            initial_time_,
-            std::array<DataVector, 3>{
-                {{gsl::at(translation_options_.value().initial_values, 0)[0],
-                  gsl::at(translation_options_.value().initial_values, 0)[1],
-                  gsl::at(translation_options_.value().initial_values, 0)[2]},
-                 {gsl::at(translation_options_.value().initial_values, 1)[0],
-                  gsl::at(translation_options_.value().initial_values, 1)[1],
-                  gsl::at(translation_options_.value().initial_values, 1)[2]},
-                 {gsl::at(translation_options_.value().initial_values, 2)[0],
-                  gsl::at(translation_options_.value().initial_values, 2)[1],
-                  gsl::at(translation_options_.value().initial_values, 2)[2]}}},
-            expiration_times.at(translation_name));
+  if (translation_map_options_.has_value()) {
+    result[translation_name] = std::make_unique<
+        FunctionsOfTime::PiecewisePolynomial<2>>(
+        initial_time_,
+        std::array<DataVector, 3>{
+            {{gsl::at(translation_map_options_.value().initial_values, 0)[0],
+              gsl::at(translation_map_options_.value().initial_values, 0)[1],
+              gsl::at(translation_map_options_.value().initial_values, 0)[2]},
+             {gsl::at(translation_map_options_.value().initial_values, 1)[0],
+              gsl::at(translation_map_options_.value().initial_values, 1)[1],
+              gsl::at(translation_map_options_.value().initial_values, 1)[2]},
+             {gsl::at(translation_map_options_.value().initial_values, 2)[0],
+              gsl::at(translation_map_options_.value().initial_values, 2)[1],
+              gsl::at(translation_map_options_.value().initial_values, 2)[2]}}},
+        expiration_times.at(translation_name));
   }
 
   // Size and Shape FunctionOfTime for objects A and B
@@ -218,28 +209,28 @@ void TimeDependentMapOptions<IsCylindrical>::build_maps(
     const std::optional<std::array<double, IsCylindrical ? 2 : 3>>&
         object_B_radii,
     const double envelope_radius, const double domain_outer_radius) {
-  if (expansion_map_options_.has_value() or rotation_options_.has_value() or
-      translation_options_.has_value()) {
+  if (expansion_map_options_.has_value() or rotation_map_options_.has_value() or
+      translation_map_options_.has_value()) {
     rot_scale_trans_map_ = std::make_pair(
         RotScaleTrans{
             expansion_map_options_.has_value()
                 ? std::make_pair(expansion_name, expansion_outer_boundary_name)
                 : std::optional<std::pair<std::string, std::string>>{},
-            rotation_options_.has_value() ? rotation_name
-                                          : std::optional<std::string>{},
-            translation_options_.has_value() ? translation_name
-                                             : std::optional<std::string>{},
+            rotation_map_options_.has_value() ? rotation_name
+                                              : std::optional<std::string>{},
+            translation_map_options_.has_value() ? translation_name
+                                                 : std::optional<std::string>{},
             envelope_radius, domain_outer_radius,
             domain::CoordinateMaps::TimeDependent::RotScaleTrans<
                 3>::BlockRegion::Inner},
         RotScaleTrans{
             expansion_map_options_.has_value()
                 ? std::make_pair(expansion_name, expansion_outer_boundary_name)
                 : std::optional<std::pair<std::string, std::string>>{},
-            rotation_options_.has_value() ? rotation_name
-                                          : std::optional<std::string>{},
-            translation_options_.has_value() ? translation_name
-                                             : std::optional<std::string>{},
+            rotation_map_options_.has_value() ? rotation_name
+                                              : std::optional<std::string>{},
+            translation_map_options_.has_value() ? translation_name
+                                                 : std::optional<std::string>{},
             envelope_radius, domain_outer_radius,
             domain::CoordinateMaps::TimeDependent::RotScaleTrans<
                 3>::BlockRegion::Transition});

src/Domain/Creators/BinaryCompactObjectHelpers.hpp → src/Domain/Creators/TimeDependentOptions/BinaryCompactObject.hpp

@@ -17,8 +17,8 @@
 #include "Domain/CoordinateMaps/TimeDependent/Rotation.hpp"
 #include "Domain/CoordinateMaps/TimeDependent/Shape.hpp"
 #include "Domain/CoordinateMaps/TimeDependent/ShapeMapTransitionFunctions/ShapeMapTransitionFunction.hpp"
-#include "Domain/Creators/ShapeMapOptions.hpp"
-#include "Domain/Creators/SphereTimeDependentMaps.hpp"
+#include "Domain/Creators/TimeDependentOptions/ShapeMap.hpp"
+#include "Domain/Creators/TimeDependentOptions/Sphere.hpp"
 #include "Domain/FunctionsOfTime/FunctionOfTime.hpp"
 #include "Domain/Structure/ObjectLabel.hpp"
 #include "Options/Auto.hpp"
@@ -39,22 +39,6 @@ struct Inertial;
 /// Namespace used to hold things used in both the BinaryCompactObject and
 /// CylindricalBinaryCompactObject domain creators.
 namespace domain::creators::bco {
-
-/*!
- * \brief Create a set of centers of objects for the binary domains.
- *
- * \details Will add the following centers to the set:
- *
- * - Center: The origin
- * - CenterA: Center of object A
- * - CenterB: Center of object B
- *
- * \return Object required by the DomainCreator%s
- */
-std::unordered_map<std::string, tnsr::I<double, 3, Frame::Grid>>
-create_grid_anchors(const std::array<double, 3>& center_a,
-                    const std::array<double, 3>& center_b);
-
 namespace detail {
 // Convenience type alias
 template <typename... Maps>
@@ -259,8 +243,8 @@ struct TimeDependentMapOptions {
   TimeDependentMapOptions(
       double initial_time,
       std::optional<ExpansionMapOptions> expansion_map_options,
-      std::optional<RotationMapOptions> rotation_options,
-      std::optional<TranslationMapOptions> translation_options,
+      std::optional<RotationMapOptions> rotation_map_options,
+      std::optional<TranslationMapOptions> translation_map_options,
       std::optional<ShapeMapOptions<domain::ObjectLabel::A>> shape_options_A,
       std::optional<ShapeMapOptions<domain::ObjectLabel::B>> shape_options_B,
       const Options::Context& context = {});
@@ -384,8 +368,8 @@ struct TimeDependentMapOptions {
 
   double initial_time_{std::numeric_limits<double>::signaling_NaN()};
   std::optional<ExpansionMapOptions> expansion_map_options_{};
-  std::optional<RotationMapOptions> rotation_options_{};
-  std::optional<TranslationMapOptions> translation_options_{};
+  std::optional<RotationMapOptions> rotation_map_options_{};
+  std::optional<TranslationMapOptions> translation_map_options_{};
   std::optional<ShapeMapOptions<domain::ObjectLabel::A>> shape_options_A_{};
   std::optional<ShapeMapOptions<domain::ObjectLabel::B>> shape_options_B_{};
   std::array<std::optional<double>, 2> inner_radii_{};

src/Domain/Creators/TimeDependentOptions/CMakeLists.txt

@@ -0,0 +1,21 @@
+# Distributed under the MIT License.
+# See LICENSE.txt for details.
+
+spectre_target_sources(
+  ${LIBRARY}
+  PRIVATE
+  BinaryCompactObject.cpp
+  FromVolumeFile.cpp
+  ShapeMap.cpp
+  Sphere.cpp
+)
+
+spectre_target_headers(
+  ${LIBRARY}
+  INCLUDE_DIRECTORY ${CMAKE_SOURCE_DIR}/src
+  HEADERS
+  BinaryCompactObject.hpp
+  FromVolumeFile.hpp
+  ShapeMap.hpp
+  Sphere.hpp
+  )