Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <cstddef>
       7             : #include <memory>
       8             : #include <string>
       9             : #include <unordered_map>
      10             : #include <vector>
      11             : 
      12             : #include "IO/H5/TensorData.hpp"
      13             : #include "Options/String.hpp"
      14             : #include "ParallelAlgorithms/Events/ObserveConstantsPerElement.hpp"
      15             : #include "ParallelAlgorithms/EventsAndTriggers/Event.hpp"
      16             : #include "Utilities/Serialization/CharmPupable.hpp"
      17             : #include "Utilities/TMPL.hpp"
      18             : #include "Utilities/TypeTraits/IsA.hpp"
      19             : 
      20             : /// \cond
      21             : enum class FloatingPointType;
      22             : template <size_t VolumeDim>
      23             : class Domain;
      24             : template <size_t VolumeDim>
      25             : class ElementId;
      26             : class TimeDelta;
      27             : namespace domain {
      28             : namespace FunctionsOfTime {
      29             : class FunctionOfTime;
      30             : }  // namespace FunctionsOfTime
      31             : namespace Tags {
      32             : template <size_t VolumeDim>
      33             : struct Domain;
      34             : struct FunctionsOfTime;
      35             : template <size_t VolumeDim, typename Frame>
      36             : struct MinimumGridSpacing;
      37             : }  // namespace Tags
      38             : }  // namespace domain
      39             : namespace Frame {
      40             : struct Inertial;
      41             : }  // namespace Frame
      42             : namespace Parallel {
      43             : template <typename Metavariables>
      44             : class GlobalCache;
      45             : }  // namespace Parallel
      46             : namespace Tags {
      47             : template <typename Tag>
      48             : struct HistoryEvolvedVariables;
      49             : struct Time;
      50             : struct TimeStep;
      51             : }  // namespace Tags
      52             : namespace TimeSteppers {
      53             : template <typename Vars>
      54             : class History;
      55             : }  // namespace TimeSteppers
      56             : /// \endcond
      57             : 
      58             : namespace dg::Events {
      59             : /*!
      60             :  * \brief %Observe the time step in the volume.
      61             :  *
      62             :  * Observe the time step size in each element.  Each element is output
      63             :  * as a single cell with two points per dimension and the observation
      64             :  * constant on all those points.
      65             :  *
      66             :  * Writes volume quantities:
      67             :  * - InertialCoordinates (only element corners)
      68             :  * - Time step
      69             :  * - Slab fraction
      70             :  * - Minimum grid spacing
      71             :  * - Integration order
      72             :  */
      73             : template <typename System>
      74           1 : class ObserveTimeStepVolume
      75             :     : public ObserveConstantsPerElement<System::volume_dim> {
      76             :  public:
      77           0 :   static constexpr size_t volume_dim = System::volume_dim;
      78             :   // The variables are only used to get the integration order, which
      79             :   // should be the same for all of them in a split-variables system.
      80           0 :   using variables_tag = tmpl::conditional_t<
      81             :       tt::is_a_v<tmpl::list, typename System::variables_tag>,
      82             :       tmpl::front<typename System::variables_tag>,
      83             :       typename System::variables_tag>;
      84             : 
      85             :   /// \cond
      86             :   explicit ObserveTimeStepVolume(CkMigrateMessage* m);
      87             :   using PUP::able::register_constructor;
      88             :   WRAPPED_PUPable_decl_template(ObserveTimeStepVolume);  // NOLINT
      89             :   /// \endcond
      90             : 
      91           0 :   static constexpr Options::String help =
      92             :       "Observe the time step and integration order in the volume.";
      93             : 
      94           0 :   ObserveTimeStepVolume();
      95             : 
      96           0 :   ObserveTimeStepVolume(const std::string& subfile_name,
      97             :                         ::FloatingPointType coordinates_floating_point_type,
      98             :                         ::FloatingPointType floating_point_type);
      99             : 
     100           0 :   using compute_tags_for_observation_box = tmpl::list<>;
     101             : 
     102           0 :   using return_tags = tmpl::list<>;
     103           0 :   using argument_tags =
     104             :       tmpl::list<::Tags::Time, ::domain::Tags::FunctionsOfTime,
     105             :                  ::domain::Tags::Domain<volume_dim>, ::Tags::TimeStep,
     106             :                  domain::Tags::MinimumGridSpacing<volume_dim, Frame::Inertial>,
     107             :                  ::Tags::HistoryEvolvedVariables<variables_tag>>;
     108             : 
     109             :   template <typename Metavariables, typename ParallelComponent>
     110           0 :   void operator()(
     111             :       const double time,
     112             :       const std::unordered_map<
     113             :           std::string,
     114             :           std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>>&
     115             :           functions_of_time,
     116             :       const Domain<volume_dim>& domain, const TimeDelta& time_step,
     117             :       const double minimum_grid_spacing,
     118             :       const TimeSteppers::History<typename variables_tag::type>& history,
     119             :       Parallel::GlobalCache<Metavariables>& cache,
     120             :       const ElementId<volume_dim>& element_id,
     121             :       const ParallelComponent* const component,
     122             :       const Event::ObservationValue& observation_value) const {
     123             :     std::vector<TensorComponent> components =
     124             :         assemble_data(time, functions_of_time, domain, element_id, time_step,
     125             :                       minimum_grid_spacing, history);
     126             : 
     127             :     this->observe(components, cache, element_id, component, observation_value);
     128             :   }
     129             : 
     130           1 :   bool needs_evolved_variables() const override;
     131             : 
     132             :  private:
     133           0 :   std::vector<TensorComponent> assemble_data(
     134             :       double time,
     135             :       const std::unordered_map<
     136             :           std::string,
     137             :           std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>>&
     138             :           functions_of_time,
     139             :       const Domain<volume_dim>& domain, const ElementId<volume_dim>& element_id,
     140             :       const TimeDelta& time_step, double minimum_grid_spacing,
     141             :       const TimeSteppers::History<typename variables_tag::type>& history) const;
     142             : };
     143             : }  // namespace dg::Events