ProductOfConditions.hpp
1 // Distributed under the MIT License.
2 // See LICENSE.txt for details.
3 
4 #pragma once
5 
6 #include <cstddef>
7 #include <memory>
8 #include <optional>
9 #include <pup.h>
10 #include <string>
11 #include <utility>
12 
13 #include "DataStructures/DataBox/PrefixHelpers.hpp"
14 #include "DataStructures/DataVector.hpp"
16 #include "Evolution/DiscontinuousGalerkin/Actions/ComputeTimeDerivativeHelpers.hpp"
17 #include "Evolution/Systems/GeneralizedHarmonic/BoundaryConditions/Factory.hpp"
18 #include "Evolution/Systems/GeneralizedHarmonic/System.hpp"
19 #include "Evolution/Systems/GrMhd/GhValenciaDivClean/BoundaryConditions/BoundaryCondition.hpp"
20 #include "Evolution/Systems/GrMhd/GhValenciaDivClean/Tags.hpp"
21 #include "Evolution/Systems/GrMhd/ValenciaDivClean/BoundaryConditions/Factory.hpp"
22 #include "Evolution/Systems/GrMhd/ValenciaDivClean/System.hpp"
23 #include "NumericalAlgorithms/DiscontinuousGalerkin/Formulation.hpp"
24 #include "Options/Options.hpp"
26 #include "Utilities/Gsl.hpp"
27 #include "Utilities/TMPL.hpp"
28 #include "Utilities/TaggedTuple.hpp"
29 
31 namespace detail {
32 
33 // Implementation for expanding the combination of packs for full compatibility
34 // with all possible combination of tag lists that can be used for constructing
35 // `BoundaryCondition` structs.
36 template <
37  typename DerivedGhCondition, typename DerivedValenciaCondition,
38  typename GhEvolvedTagList, typename ValenciaEvolvedTagList,
39  typename GhFluxTagList, typename ValenicaFluxTagList,
40  typename GhInteriorEvolvedTagList, typename ValenciaInteriorEvolvedTagList,
41  typename GhInteriorPrimitiveTagList, typename ValenciaInteriorPrimitiveTgs,
42  typename GhInteriorTempTagList, typename ValenciaInteriorTempTagList,
43  typename DeduplicatedTempTagList, typename GhInteriorDtTagList,
44  typename ValenciaInteriorDtTagList, typename GhInteriorDerivTagList,
45  typename ValenciaInteriorDerivTagList, typename GhGridlessTagList,
46  typename ValenciaGridlessTagList, typename DeduplicatedGridlessTagList>
47 struct ProductOfConditionsImpl;
48 
49 template <
50  typename DerivedGhCondition, typename DerivedValenciaCondition,
51  typename... GhEvolvedTags, typename... ValenciaEvolvedTags,
52  typename... GhFluxTags, typename... ValenciaFluxTags,
53  typename... GhInteriorEvolvedTags, typename... ValenciaInteriorEvolvedTags,
54  typename... GhInteriorPrimitiveTags,
55  typename... ValenciaInteriorPrimitiveTags, typename... GhInteriorTempTags,
56  typename... ValenciaInteriorTempTags, typename... DeduplicatedTempTags,
57  typename... GhInteriorDtTags, typename... ValenciaInteriorDtTags,
58  typename... GhInteriorDerivTags, typename... ValenciaInteriorDerivTags,
59  typename... GhGridlessTags, typename... ValenciaGridlessTags,
60  typename... DeduplicatedGridlessTags>
61 struct ProductOfConditionsImpl<
62  DerivedGhCondition, DerivedValenciaCondition, tmpl::list<GhEvolvedTags...>,
63  tmpl::list<ValenciaEvolvedTags...>, tmpl::list<GhFluxTags...>,
64  tmpl::list<ValenciaFluxTags...>, tmpl::list<GhInteriorEvolvedTags...>,
65  tmpl::list<ValenciaInteriorEvolvedTags...>,
66  tmpl::list<GhInteriorPrimitiveTags...>,
67  tmpl::list<ValenciaInteriorPrimitiveTags...>,
68  tmpl::list<GhInteriorTempTags...>, tmpl::list<ValenciaInteriorTempTags...>,
69  tmpl::list<DeduplicatedTempTags...>, tmpl::list<GhInteriorDtTags...>,
70  tmpl::list<ValenciaInteriorDtTags...>, tmpl::list<GhInteriorDerivTags...>,
71  tmpl::list<ValenciaInteriorDerivTags...>, tmpl::list<GhGridlessTags...>,
72  tmpl::list<ValenciaGridlessTags...>,
73  tmpl::list<DeduplicatedGridlessTags...>> {
74  // In the current setup, we aren't given type information about the possible
75  // arguments to `BoundaryCorrection`s directly, so we just need to support all
76  // possibilities of (GH BoundaryCorrection)x(Valencia BoundaryCorrection) with
77  // explicit overloads of `dg_ghost`.
78  // This can be solved with (more) template logic instead if in the future
79  // `BoundaryCondition`s can supply stronger type constraints
80 
81  template <typename... GridlessVariables>
82  static std::optional<std::string> dg_ghost(
83  const DerivedGhCondition& gh_condition,
84  const DerivedValenciaCondition& valencia_condition,
85 
87  const gsl::not_null<
88  typename ValenciaEvolvedTags::type*>... valencia_variables,
89 
91  const gsl::not_null<typename ValenciaFluxTags::type*>... valencia_fluxes,
92 
93  const gsl::not_null<Scalar<DataVector>*> gamma1,
94  const gsl::not_null<Scalar<DataVector>*> gamma2,
96  const gsl::not_null<tnsr::I<DataVector, 3, Frame::Inertial>*> shift,
97  const gsl::not_null<tnsr::II<DataVector, 3_st, Frame::Inertial>*>
98  inv_spatial_metric,
99  const std::optional<tnsr::I<DataVector, 3_st, Frame::Inertial>>&
100  face_mesh_velocity,
101  const tnsr::i<DataVector, 3_st, Frame::Inertial>& normal_covector,
102  const tnsr::I<DataVector, 3_st, Frame::Inertial>& normal_vector,
103 
104  const typename GhInteriorEvolvedTags::type&... gh_int_evolved_variables,
105  const typename ValenciaInteriorEvolvedTags::
106  type&... valencia_int_evolved_variables,
107 
108  const typename GhInteriorPrimitiveTags::type&... gh_int_prim_variables,
109  const typename ValenciaInteriorPrimitiveTags::
110  type&... valencia_int_prim_variables,
111 
112  const typename DeduplicatedTempTags::type&... temp_variables,
113 
114  const typename GhInteriorDtTags::type&... gh_int_dt_variables,
115  const typename ValenciaInteriorDtTags::type&... valencia_int_dt_variables,
116 
117  const typename GhInteriorDerivTags::type&... gh_int_deriv_variables,
118  const typename ValenciaInteriorDerivTags::
119  type&... valencia_int_deriv_variables,
120 
121  const GridlessVariables&... gridless_variables) noexcept {
122  using gridless_tags_and_types =
123  tmpl::map<tmpl::pair<DeduplicatedGridlessTags, GridlessVariables>...>;
124 
126  Tags::detail::TemporaryReference<
127  DeduplicatedGridlessTags,
128  tmpl::at<gridless_tags_and_types, DeduplicatedGridlessTags>>...,
129  Tags::detail::TemporaryReference<DeduplicatedTempTags>...>
130  shuffle_refs{gridless_variables..., temp_variables...};
131 
132  auto gh_string = gh_condition.dg_ghost(
133  gh_variables..., gh_fluxes..., gamma1, gamma2, lapse, shift,
134  inv_spatial_metric, face_mesh_velocity, normal_covector, normal_vector,
135  gh_int_evolved_variables..., gh_int_prim_variables...,
136  tuples::get<Tags::detail::TemporaryReference<GhInteriorTempTags>>(
137  shuffle_refs)...,
138  gh_int_dt_variables..., gh_int_deriv_variables...,
139  tuples::get<Tags::detail::TemporaryReference<
140  GhGridlessTags, tmpl::at<gridless_tags_and_types, GhGridlessTags>>>(
141  shuffle_refs)...);
142  auto valencia_string = valencia_condition.dg_ghost(
143  valencia_variables..., valencia_fluxes..., lapse, shift,
144  inv_spatial_metric, face_mesh_velocity, normal_covector, normal_vector,
145  valencia_int_evolved_variables..., valencia_int_prim_variables...,
146  tuples::get<Tags::detail::TemporaryReference<ValenciaInteriorTempTags>>(
147  shuffle_refs)...,
148  valencia_int_dt_variables..., valencia_int_deriv_variables...,
149  tuples::get<Tags::detail::TemporaryReference<
150  ValenciaGridlessTags,
151  tmpl::at<gridless_tags_and_types, ValenciaGridlessTags>>>(
152  shuffle_refs)...);
153  if (not gh_string.has_value()) {
154  return valencia_string;
155  }
156  if (not valencia_string.has_value()) {
157  return gh_string;
158  }
159  return gh_string.value() + ";" + valencia_string.value();
160  }
161 
162  template <typename... GridlessVariables>
163  static std::optional<std::string> dg_outflow(
164  const DerivedGhCondition& gh_condition,
165  const DerivedValenciaCondition& valencia_condition,
166 
167  const std::optional<tnsr::I<DataVector, 3_st, Frame::Inertial>>&
168  face_mesh_velocity,
169  const tnsr::i<DataVector, 3_st, Frame::Inertial>& normal_covector,
170  const tnsr::I<DataVector, 3_st, Frame::Inertial>& normal_vector,
171 
172  const typename GhInteriorEvolvedTags::type&... gh_int_evolved_variables,
173  const typename ValenciaInteriorEvolvedTags::
174  type&... valencia_int_evolved_variables,
175 
176  const typename GhInteriorPrimitiveTags::type&... gh_int_prim_variables,
177  const typename ValenciaInteriorPrimitiveTags::
178  type&... valencia_int_prim_variables,
179 
180  const typename DeduplicatedTempTags::type&... temp_variables,
181 
182  const typename GhInteriorDtTags::type&... gh_int_dt_variables,
183  const typename ValenciaInteriorDtTags::type&... valencia_int_dt_variables,
184 
185  const typename GhInteriorDerivTags::type&... gh_int_deriv_variables,
186  const typename ValenciaInteriorDerivTags::
187  type&... valencia_int_deriv_variables,
188 
189  const GridlessVariables&... gridless_variables) noexcept {
190  using gridless_tags_and_types =
191  tmpl::map<tmpl::pair<DeduplicatedGridlessTags, GridlessVariables>...>;
192 
194  Tags::detail::TemporaryReference<
195  DeduplicatedGridlessTags,
196  tmpl::at<gridless_tags_and_types, DeduplicatedGridlessTags>>...,
197  Tags::detail::TemporaryReference<DeduplicatedTempTags>...>
198  shuffle_refs{gridless_variables..., temp_variables...};
199 
200  auto gh_string = gh_condition.dg_outflow(
201  face_mesh_velocity, normal_covector, normal_vector,
202  gh_int_evolved_variables..., gh_int_prim_variables...,
203  tuples::get<Tags::detail::TemporaryReference<GhInteriorTempTags>>(
204  shuffle_refs)...,
205  gh_int_dt_variables..., gh_int_deriv_variables...,
206  tuples::get<Tags::detail::TemporaryReference<
207  GhGridlessTags, tmpl::at<gridless_tags_and_types, GhGridlessTags>>>(
208  shuffle_refs)...);
209  auto valencia_string = valencia_condition.dg_outflow(
210  face_mesh_velocity, normal_covector, normal_vector,
211  valencia_int_evolved_variables..., valencia_int_prim_variables...,
212  tuples::get<Tags::detail::TemporaryReference<ValenciaInteriorTempTags>>(
213  shuffle_refs)...,
214  valencia_int_dt_variables..., valencia_int_deriv_variables...,
215  tuples::get<Tags::detail::TemporaryReference<
216  ValenciaGridlessTags,
217  tmpl::at<gridless_tags_and_types, ValenciaGridlessTags>>>(
218  shuffle_refs)...);
219  if (not gh_string.has_value()) {
220  return valencia_string;
221  }
222  if (not valencia_string.has_value()) {
223  return gh_string;
224  }
225  return gh_string.value() + ";" + valencia_string.value();
226  }
227 
228  template <typename... GridlessVariables>
229  static std::optional<std::string> dg_time_derivative(
230  const DerivedGhCondition& gh_condition,
231  const DerivedValenciaCondition& valencia_condition,
232 
233  const gsl::not_null<typename GhEvolvedTags::type*>... gh_dt_variables,
234  const gsl::not_null<
235  typename ValenciaEvolvedTags::type*>... valencia_dt_variables,
236 
237  const std::optional<tnsr::I<DataVector, 3_st, Frame::Inertial>>&
238  face_mesh_velocity,
239  const tnsr::i<DataVector, 3_st, Frame::Inertial>& normal_covector,
240  const tnsr::I<DataVector, 3_st, Frame::Inertial>& normal_vector,
241 
242  const typename GhInteriorEvolvedTags::type&... gh_int_evolved_variables,
243  const typename ValenciaInteriorEvolvedTags::
244  type&... valencia_int_evolved_variables,
245 
246  const typename GhInteriorPrimitiveTags::type&... gh_int_prim_variables,
247  const typename ValenciaInteriorPrimitiveTags::
248  type&... valencia_int_prim_variables,
249 
250  const typename DeduplicatedTempTags::type&... temp_variables,
251 
252  const typename GhInteriorDtTags::type&... gh_int_dt_variables,
253  const typename ValenciaInteriorDtTags::type&... valencia_int_dt_variables,
254 
255  const typename GhInteriorDerivTags::type&... gh_int_deriv_variables,
256  const typename ValenciaInteriorDerivTags::
257  type&... valencia_int_deriv_variables,
258 
259  const GridlessVariables&... gridless_variables) noexcept {
260  using gridless_tags_and_types =
261  tmpl::map<tmpl::pair<DeduplicatedGridlessTags, GridlessVariables>...>;
262 
264  Tags::detail::TemporaryReference<
265  DeduplicatedGridlessTags,
266  tmpl::at<gridless_tags_and_types, DeduplicatedGridlessTags>>...,
267  Tags::detail::TemporaryReference<DeduplicatedTempTags>...>
268  shuffle_refs{gridless_variables..., temp_variables...};
269 
270  auto gh_string = gh_condition.dg_time_derivative(
271  gh_dt_variables..., face_mesh_velocity, normal_covector, normal_vector,
272  gh_int_evolved_variables..., gh_int_prim_variables...,
273  tuples::get<Tags::detail::TemporaryReference<GhInteriorTempTags>>(
274  shuffle_refs)...,
275  gh_int_dt_variables..., gh_int_deriv_variables...,
276  tuples::get<Tags::detail::TemporaryReference<
277  GhGridlessTags, tmpl::at<gridless_tags_and_types, GhGridlessTags>>>(
278  shuffle_refs)...);
279  auto valencia_string = valencia_condition.dg_time_derivative(
280  valencia_dt_variables..., face_mesh_velocity, normal_covector,
281  normal_vector, valencia_int_evolved_variables...,
282  valencia_int_prim_variables...,
283  tuples::get<Tags::detail::TemporaryReference<ValenciaInteriorTempTags>>(
284  shuffle_refs)...,
285  valencia_int_dt_variables..., valencia_int_deriv_variables...,
286  tuples::get<Tags::detail::TemporaryReference<
287  ValenciaGridlessTags,
288  tmpl::at<gridless_tags_and_types, ValenciaGridlessTags>>>(
289  shuffle_refs)...);
290  if (not gh_string.has_value()) {
291  return valencia_string;
292  }
293  if (not valencia_string.has_value()) {
294  return gh_string;
295  }
296  return gh_string.value() + ";" + valencia_string.value();
297  }
298 };
299 } // namespace detail
300 
301 /*!
302  * \brief Apply a boundary condition to the combined Generalized Harmonic (GH)
303  * and Valencia GRMHD system using the boundary conditions defined separately
304  * for the GH and Valencia systems.
305  *
306  * \details The implementation of this boundary condition applies the
307  * `DerivedGhCondition` followed by the `DerivedValenciaCondition`.
308  * To be consistent, both derived conditions must have the same `bc_type`. It is
309  * anticipated that the systems are sufficiently independent that the order of
310  * application is inconsequential.
311  * \note The constraint of matching `bc_type`s will likely need to be relaxed in
312  * future changes to permit separate boundary condition calculations for the two
313  * sytems.
314  */
315 template <typename DerivedGhCondition, typename DerivedValenciaCondition>
317  public:
318  using dg_interior_evolved_variables_tags = tmpl::append<
319  typename DerivedGhCondition::dg_interior_evolved_variables_tags,
320  typename DerivedValenciaCondition::dg_interior_evolved_variables_tags>;
321  using dg_interior_primitive_variables_tags = tmpl::append<
322  tmpl::list<>,
323  typename DerivedValenciaCondition::dg_interior_primitive_variables_tags>;
324  using dg_interior_temporary_tags = tmpl::remove_duplicates<tmpl::append<
325  typename DerivedGhCondition::dg_interior_temporary_tags,
326  typename DerivedValenciaCondition::dg_interior_temporary_tags>>;
327  using dg_gridless_tags = tmpl::remove_duplicates<
328  tmpl::append<typename DerivedGhCondition::dg_gridless_tags,
329  typename DerivedValenciaCondition::dg_gridless_tags>>;
330  using dg_interior_dt_vars_tags = tmpl::append<
331  evolution::dg::Actions::detail::get_dt_vars_from_boundary_condition<
332  DerivedGhCondition>,
333  evolution::dg::Actions::detail::get_dt_vars_from_boundary_condition<
334  DerivedValenciaCondition>>;
335  using dg_interior_deriv_vars_tags = tmpl::append<
336  evolution::dg::Actions::detail::get_deriv_vars_from_boundary_condition<
337  DerivedGhCondition>,
338  evolution::dg::Actions::detail::get_deriv_vars_from_boundary_condition<
339  DerivedValenciaCondition>>;
340 
341  using product_of_conditions_impl = detail::ProductOfConditionsImpl<
342  DerivedGhCondition, DerivedValenciaCondition,
343  typename GeneralizedHarmonic::System<3_st>::variables_tag::tags_list,
344  typename grmhd::ValenciaDivClean::System::variables_tag::tags_list,
346  ::Tags::Flux,
347  typename GeneralizedHarmonic::System<3_st>::flux_variables,
348  tmpl::size_t<3_st>, Frame::Inertial>,
350  typename grmhd::ValenciaDivClean::System::flux_variables,
351  tmpl::size_t<3_st>, Frame::Inertial>,
352  typename DerivedGhCondition::dg_interior_evolved_variables_tags,
353  typename DerivedValenciaCondition::dg_interior_evolved_variables_tags,
354  tmpl::list<>,
355  typename DerivedValenciaCondition::dg_interior_primitive_variables_tags,
356  typename DerivedGhCondition::dg_interior_temporary_tags,
357  typename DerivedValenciaCondition::dg_interior_temporary_tags,
358  dg_interior_temporary_tags,
359  evolution::dg::Actions::detail::get_dt_vars_from_boundary_condition<
360  DerivedGhCondition>,
361  evolution::dg::Actions::detail::get_dt_vars_from_boundary_condition<
362  DerivedValenciaCondition>,
363  evolution::dg::Actions::detail::get_deriv_vars_from_boundary_condition<
364  DerivedGhCondition>,
365  evolution::dg::Actions::detail::get_deriv_vars_from_boundary_condition<
366  DerivedValenciaCondition>,
367  typename DerivedGhCondition::dg_gridless_tags,
368  typename DerivedValenciaCondition::dg_gridless_tags, dg_gridless_tags>;
369 
370  static std::string name() noexcept {
371  return "Product" + Options::name<DerivedGhCondition>() + "And" +
372  Options::name<DerivedValenciaCondition>();
373  }
374 
375  struct GhCondition {
376  using type = DerivedGhCondition;
377  static std::string name() noexcept {
378  return "GeneralizedHarmonic" + Options::name<DerivedGhCondition>();
379  }
380  static constexpr Options::String help{
381  "The Generalized Harmonic part of the product boundary condition"};
382  };
384  using type = DerivedValenciaCondition;
385  static std::string name() noexcept {
386  return "Valencia" + Options::name<DerivedValenciaCondition>();
387  }
388  static constexpr Options::String help{
389  "The Valencia part of the product boundary condition"};
390  };
391 
392  using options = tmpl::list<GhCondition, ValenciaCondition>;
393 
394  static constexpr Options::String help = {
395  "Direct product of a GH and ValenciaDivClean GRMHD boundary conditions. "
396  "See the documentation for the two individual boundary conditions for "
397  "further details."};
398 
399  static constexpr evolution::BoundaryConditions::Type bc_type =
400  DerivedGhCondition::bc_type;
401  static_assert(DerivedGhCondition::bc_type ==
402  DerivedValenciaCondition::bc_type,
403  "The types of the Generalized Harmonic and GRMHD boundary "
404  "conditions must be the same in ProductOfConditions");
405 
406  ProductOfConditions() = default;
407  ProductOfConditions(DerivedGhCondition gh_condition,
408  DerivedValenciaCondition valencia_condition) noexcept
409  : derived_gh_condition_{gh_condition},
410  derived_valencia_condition_{valencia_condition} {}
411  ProductOfConditions(const ProductOfConditions&) = default;
412  ProductOfConditions& operator=(const ProductOfConditions&) = default;
413  ProductOfConditions(ProductOfConditions&&) = default;
414  ProductOfConditions& operator=(ProductOfConditions&&) = default;
415  ~ProductOfConditions() override = default;
416 
417  /// \cond
418  explicit ProductOfConditions(CkMigrateMessage* msg) noexcept
419  : BoundaryCondition(msg) {}
420  using PUP::able::register_constructor;
422  domain::BoundaryConditions::BoundaryCondition, ProductOfConditions);
423  /// \endcond
424 
425  void pup(PUP::er& p) noexcept override;
426 
427  auto get_clone() const noexcept -> std::unique_ptr<
428  domain::BoundaryConditions::BoundaryCondition> override;
429 
430  template <typename... Args>
431  std::optional<std::string> dg_ghost(Args&&... args) const noexcept {
432  return product_of_conditions_impl::dg_ghost(derived_gh_condition_,
433  derived_valencia_condition_,
434  std::forward<Args>(args)...);
435  }
436 
437  template <typename... Args>
438  std::optional<std::string> dg_outflow(Args&&... args) const noexcept {
439  return product_of_conditions_impl::dg_outflow(derived_gh_condition_,
440  derived_valencia_condition_,
441  std::forward<Args>(args)...);
442  }
443 
444  template <typename... Args>
445  std::optional<std::string> dg_time_derivative(Args&&... args) const noexcept {
446  return product_of_conditions_impl::dg_time_derivative(
447  derived_gh_condition_, derived_valencia_condition_,
448  std::forward<Args>(args)...);
449  }
450 
451  private:
452  DerivedGhCondition derived_gh_condition_;
453  DerivedValenciaCondition derived_valencia_condition_;
454 };
455 
456 template <typename DerivedGhCondition, typename DerivedValenciaCondition>
457 void ProductOfConditions<DerivedGhCondition, DerivedValenciaCondition>::pup(
458  PUP::er& p) noexcept {
459  p | derived_gh_condition_;
460  p | derived_valencia_condition_;
461  BoundaryCondition::pup(p);
462 }
463 
464 template <typename DerivedGhCondition, typename DerivedValenciaCondition>
465 auto ProductOfConditions<DerivedGhCondition,
466  DerivedValenciaCondition>::get_clone() const noexcept
467  -> std::unique_ptr<domain::BoundaryConditions::BoundaryCondition> {
468  return std::make_unique<ProductOfConditions>(*this);
469 }
470 
471 /// \cond
472 template <typename DerivedGhCondition, typename DerivedValenciaCondition>
473 PUP::able::PUP_ID ProductOfConditions<DerivedGhCondition,
474  DerivedValenciaCondition>::my_PUP_ID =
475  0; // NOLINT
476 /// \endcond
477 } // namespace grmhd::GhValenciaDivClean::BoundaryConditions
std::string
CharmPupable.hpp
utility
domain::BoundaryConditions::BoundaryCondition
Base class from which all system-specific base classes must inherit.
Definition: BoundaryCondition.hpp:18
Frame::Inertial
Definition: IndexType.hpp:44
Options.hpp
db::get
const auto & get(const DataBox< TagList > &box) noexcept
Retrieve the item with tag Tag from the DataBox.
Definition: DataBox.hpp:791
Tags::Flux
Prefix indicating a flux.
Definition: Prefixes.hpp:40
grmhd::GhValenciaDivClean::BoundaryConditions::ProductOfConditions::ValenciaCondition
Definition: ProductOfConditions.hpp:383
grmhd::GhValenciaDivClean::BoundaryConditions::BoundaryCondition
The base class for Generalized Harmonic and Valencia combined boundary conditions; all boundary condi...
Definition: BoundaryCondition.hpp:60
WRAPPED_PUPable_decl_base_template
#define WRAPPED_PUPable_decl_base_template(baseClassName, className)
Mark derived template classes as serializable.
Definition: CharmPupable.hpp:32
gr::lapse
Scalar< DataType > lapse(const tnsr::I< DataType, SpatialDim, Frame > &shift, const tnsr::aa< DataType, SpatialDim, Frame > &spacetime_metric) noexcept
Compute lapse from shift and spacetime metric.
grmhd::GhValenciaDivClean::BoundaryConditions::ProductOfConditions::GhCondition
Definition: ProductOfConditions.hpp:375
cstddef
tuples::TaggedTuple
An associative container that is indexed by structs.
Definition: TaggedTuple.hpp:271
grmhd::GhValenciaDivClean::BoundaryConditions::ProductOfConditions
Apply a boundary condition to the combined Generalized Harmonic (GH) and Valencia GRMHD system using ...
Definition: ProductOfConditions.hpp:316
memory
gr::shift
tnsr::I< DataType, SpatialDim, Frame > shift(const tnsr::aa< DataType, SpatialDim, Frame > &spacetime_metric, const tnsr::II< DataType, SpatialDim, Frame > &inverse_spatial_metric) noexcept
Compute shift from spacetime metric and inverse spatial metric.
Scalar
Tensor< T, Symmetry<>, index_list<> > Scalar
Definition: TypeAliases.hpp:21
Gsl.hpp
grmhd::GhValenciaDivClean::BoundaryConditions
Boundary conditions for the combined Generalized Harmonic and Valencia GRMHD systems.
Definition: BoundaryCondition.hpp:19
Options::String
const char *const String
The string used in option structs.
Definition: Options.hpp:32
Tensor.hpp
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
optional
TMPL.hpp
gsl::not_null
Require a pointer to not be a nullptr
Definition: ReadSpecPiecewisePolynomial.hpp:13
string