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 <iomanip>
       8             : #include <map>
       9             : #include <sstream>
      10             : #include <string>
      11             : #include <unordered_map>
      12             : 
      13             : #include "DataStructures/DataBox/Prefixes.hpp"
      14             : #include "DataStructures/Variables.hpp"
      15             : #include "Domain/Structure/ElementId.hpp"
      16             : #include "Evolution/Systems/CurvedScalarWave/Tags.hpp"
      17             : #include "NumericalAlgorithms/LinearOperators/PartialDerivatives.hpp"
      18             : #include "Parallel/InboxInserters.hpp"
      19             : #include "Time/TimeStepId.hpp"
      20             : #include "Utilities/TMPL.hpp"
      21             : 
      22             : /// \cond
      23             : namespace Frame {
      24             : struct Grid;
      25             : }  // namespace Frame
      26             : /// \endcond
      27             : 
      28           1 : namespace CurvedScalarWave::Worldtube::Tags {
      29             : /*!
      30             :  * \brief Inbox of the worldtube singleton chare which receives quantities
      31             :  * projected onto spherical harmonics.
      32             :  *
      33             :  * \details Each element abutting the worldtube projects both $\Psi$ and the
      34             :  * time derivative of $\partial_t Psi$ onto spherical harmonics by integrating
      35             :  * it over the worldtube surface/boundary it is touching. These coefficients are
      36             :  * sent to this inbox.
      37             :  */
      38             : template <size_t Dim>
      39           1 : struct SphericalHarmonicsInbox
      40             :     : Parallel::InboxInserters::Map<SphericalHarmonicsInbox<Dim>> {
      41           0 :   using temporal_id = TimeStepId;
      42           0 :   using tags_list = tmpl::list<CurvedScalarWave::Tags::Psi,
      43             :                                ::Tags::dt<CurvedScalarWave::Tags::Psi>>;
      44           0 :   using type =
      45             :       std::map<temporal_id,
      46             :                std::unordered_map<ElementId<Dim>, Variables<tags_list>>>;
      47             : 
      48           0 :   static std::string output_inbox(const type& inbox,
      49             :                                   const size_t padding_size) {
      50             :     std::stringstream ss{};
      51             :     const std::string pad(padding_size, ' ');
      52             : 
      53             :     ss << std::scientific << std::setprecision(16);
      54             :     ss << pad << "SphericalHarmonicsInbox:\n";
      55             :     for (const auto& [current_time_step_id, element_id_and_vars] : inbox) {
      56             :       ss << pad << " Time: " << current_time_step_id << "\n";
      57             :       // We don't really care about the variables, just the elements
      58             :       for (const auto& [element_id, variables] : element_id_and_vars) {
      59             :         (void)variables;
      60             :         ss << pad << "  ElementId: " << element_id << "\n";
      61             :       }
      62             :     }
      63             : 
      64             :     return ss.str();
      65             :   }
      66             : };
      67             : 
      68             : /*!
      69             :  * \brief Inbox of the element chares that contains the coefficients of a Taylor
      70             :  * Series of the regular field $\Psi^R$ as well as its time derivative. The
      71             :  * elements may evaluate the coefficients at their inertial coordinates.
      72             :  */
      73             : template <size_t Dim>
      74           1 : struct RegularFieldInbox
      75             :     : Parallel::InboxInserters::Value<RegularFieldInbox<Dim>> {
      76           0 :   using tags_to_send = tmpl::list<CurvedScalarWave::Tags::Psi,
      77             :                                   ::Tags::dt<CurvedScalarWave::Tags::Psi>>;
      78           0 :   using temporal_id = TimeStepId;
      79           0 :   using type = std::map<temporal_id, Variables<tags_to_send>>;
      80             : 
      81           0 :   static std::string output_inbox(const type& inbox,
      82             :                                   const size_t padding_size) {
      83             :     std::stringstream ss{};
      84             :     const std::string pad(padding_size, ' ');
      85             : 
      86             :     ss << std::scientific << std::setprecision(16);
      87             :     ss << pad << "RegularFieldInbox:\n";
      88             :     // We don't really care about the variables, just the times
      89             :     for (const auto& [current_time_step_id, variables] : inbox) {
      90             :       (void)variables;
      91             :       ss << pad << " Time: " << current_time_step_id << "\n";
      92             :     }
      93             : 
      94             :     return ss.str();
      95             :   }
      96             : };
      97             : }  // namespace CurvedScalarWave::Worldtube::Tags