GhValenciaDivCleanBase.hpp
1 // Distributed under the MIT License.
2 // See LICENSE.txt for details.
3 
4 #pragma once
5 
6 #include <cstddef>
7 #include <vector>
8 
9 #include "ApparentHorizons/ComputeItems.hpp"
10 #include "ApparentHorizons/Tags.hpp"
11 #include "DataStructures/DataBox/PrefixHelpers.hpp"
12 #include "DataStructures/DataBox/Tag.hpp"
13 #include "Domain/Creators/Factory3D.hpp"
14 #include "Domain/Creators/RegisterDerivedWithCharm.hpp"
15 #include "Domain/Creators/TimeDependence/RegisterDerivedWithCharm.hpp"
16 #include "Domain/FunctionsOfTime/RegisterDerivedWithCharm.hpp"
17 #include "Domain/Tags.hpp"
18 #include "Domain/TagsCharacteresticSpeeds.hpp"
19 #include "Evolution/Actions/ComputeTimeDerivative.hpp"
20 #include "Evolution/ComputeTags.hpp"
21 #include "Evolution/Conservative/UpdateConservatives.hpp"
22 #include "Evolution/Conservative/UpdatePrimitives.hpp"
23 #include "Evolution/DiscontinuousGalerkin/Actions/ApplyBoundaryCorrections.hpp"
24 #include "Evolution/DiscontinuousGalerkin/Actions/ComputeTimeDerivative.hpp"
25 #include "Evolution/DiscontinuousGalerkin/DgElementArray.hpp"
26 #include "Evolution/DiscontinuousGalerkin/Initialization/Mortars.hpp"
27 #include "Evolution/DiscontinuousGalerkin/Initialization/QuadratureTag.hpp"
29 #include "Evolution/DiscontinuousGalerkin/Limiters/Minmod.hpp"
30 #include "Evolution/DiscontinuousGalerkin/Limiters/Tags.hpp"
31 #include "Evolution/DiscontinuousGalerkin/Limiters/Weno.hpp"
32 #include "Evolution/Initialization/ConservativeSystem.hpp"
33 #include "Evolution/Initialization/DgDomain.hpp"
34 #include "Evolution/Initialization/DiscontinuousGalerkin.hpp"
35 #include "Evolution/Initialization/Evolution.hpp"
36 #include "Evolution/Initialization/GrTagsForHydro.hpp"
37 #include "Evolution/Initialization/Limiter.hpp"
38 #include "Evolution/Initialization/NonconservativeSystem.hpp"
39 #include "Evolution/Initialization/SetVariables.hpp"
40 #include "Evolution/NumericInitialData.hpp"
41 #include "Evolution/Systems/GeneralizedHarmonic/BoundaryConditions/Factory.hpp"
42 #include "Evolution/Systems/GeneralizedHarmonic/BoundaryCorrections/Factory.hpp"
44 #include "Evolution/Systems/GeneralizedHarmonic/GaugeSourceFunctions/InitializeDampedHarmonic.hpp"
45 #include "Evolution/Systems/GeneralizedHarmonic/Initialize.hpp"
46 #include "Evolution/Systems/GeneralizedHarmonic/System.hpp"
47 #include "Evolution/Systems/GeneralizedHarmonic/Tags.hpp"
48 #include "Evolution/Systems/GeneralizedHarmonic/UpwindPenaltyCorrection.hpp"
49 #include "Evolution/Systems/GrMhd/GhValenciaDivClean/BoundaryConditions/ProductOfConditions.hpp"
50 #include "Evolution/Systems/GrMhd/GhValenciaDivClean/BoundaryCorrections/ProductOfCorrections.hpp"
51 #include "Evolution/Systems/GrMhd/GhValenciaDivClean/System.hpp"
52 #include "Evolution/Systems/GrMhd/ValenciaDivClean/BoundaryConditions/Factory.hpp"
53 #include "Evolution/Systems/GrMhd/ValenciaDivClean/BoundaryConditions/RegisterDerivedWithCharm.hpp"
54 #include "Evolution/Systems/GrMhd/ValenciaDivClean/BoundaryCorrections/Factory.hpp"
55 #include "Evolution/Systems/GrMhd/ValenciaDivClean/BoundaryCorrections/RegisterDerived.hpp"
56 #include "Evolution/Systems/GrMhd/ValenciaDivClean/FixConservatives.hpp"
57 #include "Evolution/Systems/GrMhd/ValenciaDivClean/KastaunEtAl.hpp"
58 #include "Evolution/Systems/GrMhd/ValenciaDivClean/NewmanHamlin.hpp"
59 #include "Evolution/Systems/GrMhd/ValenciaDivClean/PalenzuelaEtAl.hpp"
60 #include "Evolution/Systems/GrMhd/ValenciaDivClean/System.hpp"
61 #include "Evolution/Systems/GrMhd/ValenciaDivClean/Tags.hpp"
62 #include "Evolution/TypeTraits.hpp"
63 #include "Evolution/VariableFixing/Actions.hpp"
64 #include "Evolution/VariableFixing/FixToAtmosphere.hpp"
65 #include "Evolution/VariableFixing/Tags.hpp"
66 #include "IO/Importers/Actions/ReadVolumeData.hpp"
67 #include "IO/Importers/Actions/ReceiveVolumeData.hpp"
68 #include "IO/Importers/Actions/RegisterWithElementDataReader.hpp"
69 #include "IO/Importers/ElementDataReader.hpp"
70 #include "IO/Observer/Actions/ObserverRegistration.hpp"
71 #include "IO/Observer/Actions/RegisterEvents.hpp"
72 #include "IO/Observer/Helpers.hpp"
73 #include "IO/Observer/ObserverComponent.hpp"
74 #include "IO/Observer/Tags.hpp"
75 #include "NumericalAlgorithms/DiscontinuousGalerkin/Formulation.hpp"
76 #include "NumericalAlgorithms/DiscontinuousGalerkin/Tags.hpp"
77 #include "NumericalAlgorithms/Interpolation/Actions/ElementInitInterpPoints.hpp"
78 #include "NumericalAlgorithms/Interpolation/AddTemporalIdsToInterpolationTarget.hpp"
79 #include "NumericalAlgorithms/Interpolation/Callbacks/FindApparentHorizon.hpp"
80 #include "NumericalAlgorithms/Interpolation/Callbacks/ObserveTimeSeriesOnSurface.hpp"
81 #include "NumericalAlgorithms/Interpolation/CleanUpInterpolator.hpp"
82 #include "NumericalAlgorithms/Interpolation/InitializeInterpolationTarget.hpp"
83 #include "NumericalAlgorithms/Interpolation/Interpolate.hpp"
84 #include "NumericalAlgorithms/Interpolation/InterpolationTarget.hpp"
85 #include "NumericalAlgorithms/Interpolation/InterpolationTargetApparentHorizon.hpp"
86 #include "NumericalAlgorithms/Interpolation/InterpolationTargetKerrHorizon.hpp"
87 #include "NumericalAlgorithms/Interpolation/InterpolationTargetReceiveVars.hpp"
88 #include "NumericalAlgorithms/Interpolation/Interpolator.hpp"
89 #include "NumericalAlgorithms/Interpolation/InterpolatorReceivePoints.hpp"
90 #include "NumericalAlgorithms/Interpolation/InterpolatorReceiveVolumeData.hpp"
91 #include "NumericalAlgorithms/Interpolation/InterpolatorRegisterElement.hpp"
92 #include "NumericalAlgorithms/Interpolation/Tags.hpp"
93 #include "NumericalAlgorithms/Interpolation/TryToInterpolate.hpp"
94 #include "Options/Options.hpp"
95 #include "Options/Protocols/FactoryCreation.hpp"
96 #include "Parallel/Actions/SetupDataBox.hpp"
97 #include "Parallel/Actions/TerminatePhase.hpp"
99 #include "Parallel/InitializationFunctions.hpp"
100 #include "Parallel/PhaseControl/ExecutePhaseChange.hpp"
101 #include "Parallel/PhaseControl/PhaseControlTags.hpp"
102 #include "Parallel/PhaseControl/VisitAndReturn.hpp"
103 #include "Parallel/PhaseDependentActionList.hpp"
104 #include "Parallel/Reduction.hpp"
106 #include "ParallelAlgorithms/Events/Factory.hpp"
107 #include "ParallelAlgorithms/Events/ObserveErrorNorms.hpp"
108 #include "ParallelAlgorithms/Events/ObserveFields.hpp"
109 #include "ParallelAlgorithms/Events/ObserveTimeStep.hpp"
110 #include "ParallelAlgorithms/EventsAndTriggers/Actions/RunEventsAndTriggers.hpp"
111 #include "ParallelAlgorithms/EventsAndTriggers/Actions/RunEventsAndTriggers.hpp" // IWYU pragma: keep
112 #include "ParallelAlgorithms/EventsAndTriggers/Completion.hpp"
113 #include "ParallelAlgorithms/EventsAndTriggers/Event.hpp"
114 #include "ParallelAlgorithms/EventsAndTriggers/EventsAndTriggers.hpp"
115 #include "ParallelAlgorithms/EventsAndTriggers/EventsAndTriggers.hpp" // IWYU pragma: keep
116 #include "ParallelAlgorithms/EventsAndTriggers/LogicalTriggers.hpp"
118 #include "ParallelAlgorithms/EventsAndTriggers/Trigger.hpp"
119 #include "ParallelAlgorithms/Initialization/Actions/AddComputeTags.hpp"
120 #include "ParallelAlgorithms/Initialization/Actions/RemoveOptionsAndTerminatePhase.hpp"
121 #include "PointwiseFunctions/AnalyticData/GrMhd/BlastWave.hpp"
122 #include "PointwiseFunctions/AnalyticData/GrMhd/BondiHoyleAccretion.hpp"
123 #include "PointwiseFunctions/AnalyticData/GrMhd/MagneticFieldLoop.hpp"
124 #include "PointwiseFunctions/AnalyticData/GrMhd/MagneticRotor.hpp"
125 #include "PointwiseFunctions/AnalyticData/GrMhd/MagnetizedFmDisk.hpp"
126 #include "PointwiseFunctions/AnalyticData/GrMhd/OrszagTangVortex.hpp"
127 #include "PointwiseFunctions/AnalyticData/Tags.hpp"
128 #include "PointwiseFunctions/AnalyticSolutions/GeneralRelativity/KerrSchild.hpp"
129 #include "PointwiseFunctions/AnalyticSolutions/GeneralRelativity/Tov.hpp"
130 #include "PointwiseFunctions/AnalyticSolutions/GeneralRelativity/WrappedGr.hpp"
131 #include "PointwiseFunctions/AnalyticSolutions/GrMhd/AlfvenWave.hpp"
132 #include "PointwiseFunctions/AnalyticSolutions/GrMhd/BondiMichel.hpp"
133 #include "PointwiseFunctions/AnalyticSolutions/GrMhd/KomissarovShock.hpp"
134 #include "PointwiseFunctions/AnalyticSolutions/GrMhd/SmoothFlow.hpp"
135 #include "PointwiseFunctions/AnalyticSolutions/RelativisticEuler/FishboneMoncriefDisk.hpp"
136 #include "PointwiseFunctions/AnalyticSolutions/RelativisticEuler/SmoothFlow.hpp"
137 #include "PointwiseFunctions/AnalyticSolutions/RelativisticEuler/TovStar.hpp"
138 #include "PointwiseFunctions/AnalyticSolutions/Tags.hpp"
140 #include "PointwiseFunctions/GeneralRelativity/DetAndInverseSpatialMetric.hpp"
141 #include "PointwiseFunctions/GeneralRelativity/GeneralizedHarmonic/ConstraintGammas.hpp"
142 #include "PointwiseFunctions/GeneralRelativity/IndexManipulation.hpp"
144 #include "PointwiseFunctions/GeneralRelativity/Tags.hpp"
145 #include "PointwiseFunctions/Hydro/MassFlux.hpp"
146 #include "PointwiseFunctions/Hydro/Tags.hpp"
148 #include "Time/Actions/ChangeSlabSize.hpp"
149 #include "Time/Actions/ChangeStepSize.hpp"
150 #include "Time/Actions/RecordTimeStepperData.hpp"
151 #include "Time/Actions/SelfStartActions.hpp"
152 #include "Time/Actions/SelfStartActions.hpp" // IWYU pragma: keep
153 #include "Time/Actions/UpdateU.hpp"
154 #include "Time/StepChoosers/Cfl.hpp"
155 #include "Time/StepChoosers/Constant.hpp"
156 #include "Time/StepChoosers/Factory.hpp"
157 #include "Time/StepChoosers/Increase.hpp"
158 #include "Time/StepChoosers/PreventRapidIncrease.hpp"
159 #include "Time/StepChoosers/StepChooser.hpp"
160 #include "Time/StepChoosers/StepToTimes.hpp"
161 #include "Time/StepControllers/Factory.hpp"
163 #include "Time/Tags.hpp"
164 #include "Time/TimeSequence.hpp"
165 #include "Time/TimeSteppers/TimeStepper.hpp"
166 #include "Time/Triggers/TimeTriggers.hpp"
167 #include "Utilities/Blas.hpp"
170 #include "Utilities/Functional.hpp"
171 #include "Utilities/ProtocolHelpers.hpp"
172 #include "Utilities/TMPL.hpp"
173 
174 /// \cond
175 namespace Frame {
176 // IWYU pragma: no_forward_declare MathFunction
177 struct Inertial;
178 } // namespace Frame
179 namespace PUP {
180 class er;
181 } // namespace PUP
182 namespace Parallel {
183 template <typename Metavariables>
184 class CProxy_GlobalCache;
185 } // namespace Parallel
186 /// \endcond
187 
189  static constexpr size_t volume_dim = 3;
191  static constexpr bool use_damped_harmonic_rollon = true;
193  static constexpr bool local_time_stepping = false;
194 
196  using analytic_variables_tags =
197  typename system::primitive_variables_tag::tags_list;
198  using analytic_solution_fields =
199  tmpl::append<typename system::primitive_variables_tag::tags_list,
200  typename system::gh_system::variables_tag::tags_list>;
201  using ordered_list_of_primitive_recovery_schemes = tmpl::list<
205 
206  // Do not limit the divergence-cleaning field Phi or the GH fields
207  using limiter = Tags::Limiter<
212 
215 
216  enum class Phase {
217  Initialization,
218  RegisterWithElementDataReader,
219  ImportInitialData,
220  InitializeInitialDataDependentQuantities,
221  InitializeTimeStepperHistory,
222  Register,
223  LoadBalancing,
224  Evolve,
225  Exit
226  };
227 
228  static std::string phase_name(Phase phase) noexcept {
229  if (phase == Phase::LoadBalancing) {
230  return "LoadBalancing";
231  }
232  ERROR(
233  "Passed phase that should not be used in input file. Integer "
234  "corresponding to phase is: "
235  << static_cast<int>(phase));
236  }
237 
238  using initialize_initial_data_dependent_quantities_actions = tmpl::list<
240  volume_dim, use_damped_harmonic_rollon>,
245 
246  // NOLINTNEXTLINE(google-runtime-references)
247  void pup(PUP::er& /*p*/) noexcept {}
248 };
249 
250 template <typename EvolutionMetavarsDerived>
252 
253 template <template <typename, typename...> class EvolutionMetavarsDerived,
254  typename InitialData, typename... InterpolationTargetTags>
256  EvolutionMetavarsDerived<InitialData, InterpolationTargetTags...>>
257  : public virtual GhValenciaDivCleanDefaults {
258  using derived_metavars =
259  EvolutionMetavarsDerived<InitialData, InterpolationTargetTags...>;
260 
261  using initial_data = InitialData;
262  static_assert(
263  evolution::is_analytic_data_v<initial_data> xor
264  evolution::is_analytic_solution_v<initial_data>,
265  "initial_data must be either an analytic_data, an "
266  "analytic_solution, or externally provided numerical initial data");
267  // note: numeric initial data not yet fully supported; I think it will need a
268  // new wrapping class around the numeric initial data class.
269  using equation_of_state_type = typename initial_data::equation_of_state_type;
270  using equation_of_state_tag =
272 
273  using initial_data_tag =
274  tmpl::conditional_t<evolution::is_analytic_solution_v<initial_data>,
277 
278  using interpolator_source_vars =
279  tmpl::remove_duplicates<tmpl::flatten<tmpl::list<
280  typename InterpolationTargetTags::vars_to_interpolate_to_target...>>>;
281 
282  using observe_fields = tmpl::append<
283  typename system::variables_tag::tags_list,
284  typename system::primitive_variables_tag::tags_list,
285  tmpl::list<
287  volume_dim, domain_frame>>,
290  domain_frame>>,
293  domain_frame>>>>;
294 
295  struct factory_creation
296  : tt::ConformsTo<Options::protocols::FactoryCreation> {
297  using factory_classes = tmpl::map<
298  tmpl::pair<DomainCreator<volume_dim>, domain_creators<volume_dim>>,
299  tmpl::pair<
300  Event,
301  tmpl::flatten<tmpl::list<
303  dg::Events::field_observations<
304  volume_dim, Tags::Time, observe_fields,
305  tmpl::conditional_t<
306  evolution::is_analytic_solution_v<initial_data>,
307  analytic_solution_fields, tmpl::list<>>>,
308  Events::time_events<system>,
309  intrp::Events::Interpolate<3, InterpolationTargetTags,
310  interpolator_source_vars>...>>>,
311  tmpl::pair<StepChooser<StepChooserUse::LtsStep>,
312  StepChoosers::standard_step_choosers<system>>,
313  tmpl::pair<
315  StepChoosers::standard_slab_choosers<system, local_time_stepping>>,
316  tmpl::pair<StepController, StepControllers::standard_step_controllers>,
317  tmpl::pair<TimeSequence<double>,
318  TimeSequences::all_time_sequences<double>>,
319  tmpl::pair<TimeSequence<std::uint64_t>,
320  TimeSequences::all_time_sequences<std::uint64_t>>,
321  tmpl::pair<Trigger, tmpl::append<Triggers::logical_triggers,
323  };
324 
325  using interpolation_target_tags = tmpl::list<InterpolationTargetTags...>;
326 
327  using observed_reduction_data_tags =
328  observers::collect_reduction_data_tags<tmpl::push_back<
329  tmpl::at<typename factory_creation::factory_classes, Event>,
330  typename InterpolationTargetTags::post_interpolation_callback...>>;
331 
332  using phase_changes = tmpl::list<PhaseControl::Registrars::VisitAndReturn<
333  GhValenciaDivCleanTemplateBase, Phase::LoadBalancing>>;
336  using phase_change_tags_and_combines_list =
338 
339  using const_global_cache_tags = tmpl::flatten<tmpl::list<
340  tmpl::conditional_t<evolution::is_numeric_initial_data_v<initial_data>,
341  tmpl::list<>, initial_data_tag>,
345  volume_dim, domain_frame>,
347  volume_dim, domain_frame>,
349  volume_dim, domain_frame>,
351 
352  using dg_registration_list =
355 
356  template <typename... Tags>
357  static Phase determine_next_phase(
359  phase_change_decision_data,
360  const Phase& current_phase,
361  const Parallel::CProxy_GlobalCache<derived_metavars>&
362  cache_proxy) noexcept {
363  const auto next_phase = PhaseControl::arbitrate_phase_change<phase_changes>(
364  phase_change_decision_data, current_phase,
365  *(cache_proxy.ckLocalBranch()));
366  if (next_phase.has_value()) {
367  return next_phase.value();
368  }
369  switch (current_phase) {
370  case Phase::Initialization:
371  return evolution::is_numeric_initial_data_v<initial_data>
372  ? Phase::RegisterWithElementDataReader
373  : Phase::InitializeInitialDataDependentQuantities;
374  case Phase::RegisterWithElementDataReader:
375  return Phase::ImportInitialData;
376  case Phase::ImportInitialData:
377  return Phase::InitializeInitialDataDependentQuantities;
378  case Phase::InitializeInitialDataDependentQuantities:
379  return Phase::InitializeTimeStepperHistory;
380  case Phase::InitializeTimeStepperHistory:
381  return Phase::Register;
382  case Phase::Register:
383  return Phase::Evolve;
384  case Phase::Evolve:
385  return Phase::Exit;
386  case Phase::Exit:
387  ERROR(
388  "Should never call determine_next_phase with the current phase "
389  "being 'Exit'");
390  default:
391  ERROR(
392  "Unknown type of phase. Did you static_cast<Phase> an integral "
393  "value?");
394  }
395  }
396 
397  using step_actions = tmpl::flatten<tmpl::list<
400  tmpl::conditional_t<
401  local_time_stepping, tmpl::list<>,
402  tmpl::list<Actions::RecordTimeStepperData<>, Actions::UpdateU<>>>,
408 
409  using initialization_actions = tmpl::list<
415  equation_of_state_tag>,
417  evolution::is_numeric_initial_data_v<initial_data>, tmpl::list<>,
424  tmpl::conditional_t<
425  evolution::is_analytic_solution_v<initial_data>,
428  3, initial_data_tag, analytic_solution_fields>>>,
429  tmpl::list<>>,
431  StepChoosers::step_chooser_compute_tags<
438 
439  using dg_element_array_component = DgElementArray<
440  derived_metavars,
441  tmpl::flatten<tmpl::list<
442  Parallel::PhaseActions<Phase, Phase::Initialization,
443  initialization_actions>,
444  tmpl::conditional_t<
445  evolution::is_numeric_initial_data_v<initial_data>,
446  tmpl::list<
448  Phase, Phase::RegisterWithElementDataReader,
449  tmpl::list<
453  Phase, Phase::ImportInitialData,
456  typename system::variables_tag::tags_list>,
459  typename system::variables_tag::tags_list>,
461  tmpl::list<>>,
463  Phase, Phase::InitializeInitialDataDependentQuantities,
464  initialize_initial_data_dependent_quantities_actions>,
466  Phase, Phase::InitializeTimeStepperHistory,
468  Parallel::PhaseActions<Phase, Phase::Register,
469  tmpl::list<dg_registration_list,
472  Phase, Phase::Evolve,
473  tmpl::list<
479 
480  template <typename ParallelComponent>
481  struct registration_list {
482  using type = std::conditional_t<
483  std::is_same_v<ParallelComponent, dg_element_array_component>,
484  dg_registration_list, tmpl::list<>>;
485  };
486 
487  using component_list = tmpl::flatten<tmpl::list<
492  tmpl::list<>>,
496 };
FloatingPointExceptions.hpp
hydro::Tags::EquationOfState
The equation of state.
Definition: Tags.hpp:57
intrp::Tags::InterpPointInfo
The following tag is for the case in which interpolation bypasses the Interpolator ParallelComponent....
Definition: PointInfoTag.hpp:44
Tags::PointwiseL2Norm
Definition: Norms.hpp:111
GeneralizedHarmonic::Tags::GaugeConstraint
Tags corresponding to various constraints of the generalized harmonic system, and their diagnosticall...
Definition: Tags.hpp:153
RegisterDerivedClassesWithCharm.hpp
Actions::SetupDataBox
Add into the DataBox default constructed items for the collection of tags requested by any of the act...
Definition: SetupDataBox.hpp:102
GeneralizedHarmonic::ConstraintDamping::Tags::DampingFunctionGamma2
A DampingFunction to compute the constraint damping parameter .
Definition: Tags.hpp:117
std::string
PhaseControl::InitializePhaseChangeDecisionData
Initialize the Main chare's phase_change_decision_data for the option-selected PhaseChanges.
Definition: ExecutePhaseChange.hpp:169
Tags::Limiter
The global cache tag for the limiter.
Definition: Tags.hpp:42
Frame::Inertial
Definition: IndexType.hpp:44
Tags::TimeStepId
Tag for TimeStepId for the algorithm state.
Definition: Tags.hpp:33
observers::Actions::RegisterEventsWithObservers
Registers this element of a parallel component with the local Observer parallel component for each tr...
Definition: RegisterEvents.hpp:114
Limiters::Actions::SendData
Send local data needed for limiting.
Definition: LimiterActions.hpp:142
domain::Tags::Coordinates
Definition: Tags.hpp:130
Tags.hpp
LimiterActions.hpp
Options.hpp
grmhd::ValenciaDivClean::PrimitiveRecoverySchemes::PalenzuelaEtAl
Compute the primitive variables from the conservative variables using the scheme of Palenzuela et al,...
Definition: PalenzuelaEtAl.hpp:51
VariableFixing::Actions::FixVariables
Adjust variables with a variable fixer.
Definition: Actions.hpp:42
Initialization::Actions::AddComputeTags
Initialize the list of compute tags in ComputeTagsList
Definition: AddComputeTags.hpp:42
Tags.hpp
vector
std::system
T system(T... args)
Error.hpp
evolution::Tags::AnalyticCompute
Use the AnalyticSolutionTag to compute the analytic solution of the tags in AnalyticFieldsTagList.
Definition: ComputeTags.hpp:24
Limiters::Minmod
A minmod-based generalized slope limiter.
Definition: Minmod.hpp:148
Initialization::Actions::RemoveOptionsAndTerminatePhase
Definition: RemoveOptionsAndTerminatePhase.hpp:27
Initialization::Actions::Minmod
Allocate items for minmod limiter.
Definition: Limiter.hpp:38
Actions::AdvanceTime
Advance time one substep.
Definition: AdvanceTime.hpp:50
Parallel::Actions::TerminatePhase
Terminate the algorithm to proceed to the next phase.
Definition: TerminatePhase.hpp:26
GeneralizedHarmonic::gauges::Actions::InitializeDampedHarmonic
Initialize the damped harmonic gauge, either with or without a rollon function.
Definition: InitializeDampedHarmonic.hpp:95
Ricci.hpp
PhaseControl::Tags::PhaseChangeAndTriggers
Tag for the collection of triggers that indicate synchronization points at which phase changes should...
Definition: PhaseControlTags.hpp:66
evolution::OptionTags::NumericInitialData
Holds option tags for importing numeric initial data for an evolution.
Definition: Tags.hpp:40
grmhd::ValenciaDivClean::PrimitiveRecoverySchemes::KastaunEtAl
Compute the primitive variables from the conservative variables using the scheme of .
Definition: KastaunEtAl.hpp:52
DgElementArray
The parallel component responsible for managing the DG elements that compose the computational domain...
Definition: DgElementArray.hpp:43
intrp::Interpolator
ParallelComponent responsible for collecting data from Elements and interpolating it onto Interpolati...
Definition: Interpolator.hpp:23
domain::push_back
CoordinateMap< SourceFrame, TargetFrame, Maps..., NewMap > push_back(CoordinateMap< SourceFrame, TargetFrame, Maps... > old_map, NewMap new_map) noexcept
Creates a CoordinateMap by appending the new map to the end of the old maps.
Initialization::Actions::ConservativeSystem
Allocate variables needed for evolution of conservative systems.
Definition: ConservativeSystem.hpp:72
PhaseControl::Actions::ExecutePhaseChange
Check if any triggers are activated, and perform phase changes as needed.
Definition: ExecutePhaseChange.hpp:41
Events::Completion
Definition: Completion.hpp:15
ERROR
#define ERROR(m)
prints an error message to the standard error stream and aborts the program.
Definition: Error.hpp:37
Actions::UpdateConservatives
Compute the conservative variables from the primitive variables.
Definition: UpdateConservatives.hpp:32
Actions::ChangeSlabSize
Definition: ChangeSlabSize.hpp:106
Parallel::PhaseActions
List of all the actions to be executed in the specified phase.
Definition: PhaseDependentActionList.hpp:16
observers::ObserverWriter
The nodegroup parallel component that is responsible for writing data to disk.
Definition: ObserverComponent.hpp:51
StepChooser< StepChooserUse::Slab >
Definition: StepChooser.hpp:94
grmhd::GhValenciaDivClean::System
Definition: System.hpp:32
Event
Definition: Event.hpp:19
Initialization::Actions::GrTagsForHydro
Allocate and set general relativity quantities needed for evolution of some hydro systems.
Definition: GrTagsForHydro.hpp:65
grmhd::ValenciaDivClean::PrimitiveRecoverySchemes::NewmanHamlin
Compute the primitive variables from the conservative variables using the scheme of Newman and Hamlin...
Definition: NewmanHamlin.hpp:50
evolution::dg::Actions::ComputeTimeDerivative
Computes the time derivative for a DG time step.
Definition: ComputeTimeDerivative.hpp:287
importers::ElementDataReader
A nodegroup parallel component that reads in a volume data file and distributes its data to elements ...
Definition: ElementDataReader.hpp:38
evolution::dg::Initialization::Mortars
Initialize mortars between elements for exchanging boundary correction terms.
Definition: Mortars.hpp:90
cstddef
Actions::RunEventsAndTriggers
Run the events and triggers.
Definition: RunEventsAndTriggers.hpp:27
grmhd::ValenciaDivClean::Tags::TildeS
The densitized momentum density .
Definition: Tags.hpp:42
intrp::Actions::RegisterElementWithInterpolator
Invoked on DgElementArray to register all its elements with the Interpolator.
Definition: InterpolatorRegisterElement.hpp:109
evolution::dg::Initialization::Domain
Initialize items related to the basic structure of the element.
Definition: DgDomain.hpp:85
Initialization::Actions::TimeStepperHistory
Initialize time-stepper items.
Definition: Evolution.hpp:214
PhaseControl::get_phase_change_tags
tmpl::push_back< tmpl::flatten< tmpl::transform< Registration::registrants< PhaseChangeRegistrars >, detail::get_phase_change_tags_and_combines< tmpl::_1 > >>, TagsAndCombines::UsePhaseChangeArbitration > get_phase_change_tags
Metafunction for determining the merged collection of tags in phase_change_tags_and_combines_lists fr...
Definition: PhaseControlTags.hpp:114
Tags::AnalyticSolution
Definition: Tags.hpp:58
Triggers::time_triggers
tmpl::list< NearTimes, SlabCompares, Slabs, TimeCompares, Times > time_triggers
Definition: TimeTriggers.hpp:17
tuples::TaggedTuple< Tags... >
observers::Observer
The group parallel component that is responsible for reducing data to be observed.
Definition: ObserverComponent.hpp:29
grmhd::ValenciaDivClean::Tags::ConstraintDampingParameter
The constraint damping parameter for divergence cleaning.
Definition: Tags.hpp:88
Limiters::Actions::Limit
Receive limiter data from neighbors, then apply limiter.
Definition: LimiterActions.hpp:71
Trigger
Definition: Trigger.hpp:17
StepController.hpp
Tags::Time
Tag for the current time as a double.
Definition: Tags.hpp:73
GhValenciaDivCleanDefaults
Definition: GhValenciaDivCleanBase.hpp:188
GeneralizedHarmonic::Actions::InitializeGhAnd3Plus1Variables
Definition: Initialize.hpp:92
GeneralizedHarmonic::ConstraintDamping::Tags::DampingFunctionGamma0
A DampingFunction to compute the constraint damping parameter .
Definition: Tags.hpp:79
GeneralizedHarmonic::Actions::InitializeConstraints
Definition: Initialize.hpp:59
grmhd::ValenciaDivClean::Tags::TildeB
The densitized magnetic field .
Definition: Tags.hpp:49
AdvanceTime.hpp
intrp::Actions::ElementInitInterpPoints
Adds interpolation point holders to the Element's DataBox.
Definition: ElementInitInterpPoints.hpp:45
SelfStart::self_start_procedure
tmpl::flatten< tmpl::list< SelfStart::Actions::Initialize< System >, ::Actions::Label< detail::PhaseStart >, SelfStart::Actions::CheckForCompletion< detail::PhaseEnd, System >, ::Actions::AdvanceTime, SelfStart::Actions::CheckForOrderIncrease, StepActions, ::Actions::Goto< detail::PhaseStart >, ::Actions::Label< detail::PhaseEnd >, SelfStart::Actions::Cleanup, ::Actions::AdvanceTime, Parallel::Actions::TerminatePhase > > self_start_procedure
Definition: SelfStartActions.hpp:471
Tags::AnalyticData
The analytic data, with the type of the analytic data set as the template parameter.
Definition: Tags.hpp:43
Tags::EventsAndTriggers
Definition: Tags.hpp:51
GeneralizedHarmonic::Tags::FourIndexConstraint
Tags corresponding to various constraints of the generalized harmonic system, and their diagnosticall...
Definition: Tags.hpp:173
evolution::Initialization::Actions::SetVariables
Sets variables needed for evolution of hyperbolic systems.
Definition: SetVariables.hpp:54
GeneralizedHarmonic::Tags::ThreeIndexConstraint
Tags corresponding to various constraints of the generalized harmonic system, and their diagnosticall...
Definition: Tags.hpp:168
Tags::TimeStepper
Tag for a TimeStepper of type StepperType.
Definition: Tags.hpp:214
Frame
Definition: IndexType.hpp:36
Actions::UpdateU
Perform variable updates for one substep.
Definition: UpdateU.hpp:96
evolution::dg::Actions::ApplyBoundaryCorrections
Computes the boundary corrections and lifts them to the volume.
Definition: ApplyBoundaryCorrections.hpp:105
Initialization::Actions::TimeAndTimeStep
Initialize items related to time, such as the time step.
Definition: Evolution.hpp:82
AlgorithmSingleton.hpp
grmhd::ValenciaDivClean::Tags::TildeD
The densitized rest-mass density .
Definition: Tags.hpp:31
GeneralizedHarmonic::ConstraintDamping::Tags::DampingFunctionGamma1
A DampingFunction to compute the constraint damping parameter .
Definition: Tags.hpp:98
importers::Actions::ReceiveVolumeData
Wait for data from a volume data file to arrive and directly move it into the DataBox.
Definition: ReceiveVolumeData.hpp:30
GhValenciaDivCleanTemplateBase
Definition: GhValenciaDivCleanBase.hpp:251
UpdateU.hpp
std::conditional_t
Actions::UpdatePrimitives
Compute the primitive variables from the conservative variables.
Definition: UpdatePrimitives.hpp:35
Blas.hpp
importers::Actions::ReadVolumeData
Read a volume data file and distribute the data to all registered elements.
Definition: ReadVolumeData.hpp:67
Christoffel.hpp
Equations.hpp
tt::ConformsTo
Indicate a class conforms to the Protocol.
Definition: ProtocolHelpers.hpp:22
intrp::Events::Interpolate
Does an interpolation onto InterpolationTargetTag by calling Actions on the Interpolator and Interpol...
Definition: Interpolate.hpp:53
Parallel
Functionality for parallelization.
Definition: ElementReceiveInterpPoints.hpp:13
importers::Actions::RegisterWithElementDataReader
Register an element with the volume data reader component.
Definition: RegisterWithElementDataReader.hpp:42
VariableFixing::FixToAtmosphere
Fix the primitive variables to an atmosphere in low density regions.
Definition: FixToAtmosphere.hpp:65
TMPL.hpp
gsl::not_null
Require a pointer to not be a nullptr
Definition: ReadSpecPiecewisePolynomial.hpp:13
grmhd::ValenciaDivClean::FixConservatives
Fix conservative variables using method developed by Foucart.
Definition: FixConservatives.hpp:99
grmhd::ValenciaDivClean::Tags::TildeTau
The densitized energy density .
Definition: Tags.hpp:36
intrp::InterpolationTarget
ParallelComponent representing a set of points to be interpolated to and a function to call upon inte...
Definition: InterpolationTarget.hpp:347