Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include "DataStructures/DataBox/Prefixes.hpp"
       7             : #include "DataStructures/Tensor/TypeAliases.hpp"
       8             : #include "NumericalAlgorithms/SphericalHarmonics/Tags.hpp"
       9             : #include "Utilities/TaggedTuple.hpp"
      10             : 
      11             : /// \cond
      12             : class DataVector;
      13             : namespace ylm {
      14             : template <typename Frame>
      15             : class Strahlkorper;
      16             : }  // namespace ylm
      17             : namespace domain {
      18             : enum class ObjectLabel;
      19             : }  // namespace domain
      20             : /// \endcond
      21             : 
      22             : /// \ingroup ControlSystemGroup
      23             : /// All tags that will be used in the LinkedMessageQueue's within control
      24             : /// systems.
      25             : ///
      26             : /// These tags will be used to retrieve the results of the measurements that
      27             : /// were sent to the control system which have been placed inside a
      28             : /// LinkedMessageQueue.
      29           1 : namespace control_system::QueueTags {
      30             : /// \ingroup ControlSystemGroup
      31             : /// Holds the centers of each horizon from measurements as DataVectors
      32             : template <::domain::ObjectLabel Horizon>
      33           1 : struct Center {
      34           0 :   using type = DataVector;
      35             : };
      36             : 
      37             : /// \ingroup ControlSystemGroup
      38             : /// Holds a full strahlkorper from measurements that represents a horizon
      39             : template <typename Frame>
      40           1 : struct Horizon {
      41           0 :   using type = ylm::Strahlkorper<Frame>;
      42             : };
      43             : 
      44             : /// \ingroup ControlSystemGroup
      45             : /// Holds a full strahlkorper from measurements for the excision surface
      46             : template <typename Frame>
      47           1 : struct ExcisionSurface {
      48           0 :   using type = ylm::Strahlkorper<Frame>;
      49             : };
      50             : 
      51             : /// \ingroup ControlSystemGroup
      52             : /// Holds the lapse on the `ExcisionSurface`
      53           1 : struct LapseOnExcisionSurface {
      54           0 :   using type = Scalar<DataVector>;
      55             : };
      56             : 
      57             : /*!
      58             :  * \ingroup ControlSystemGroup
      59             :  * \brief Holds a quantity that's similar to the shift, but isn't the shift, on
      60             :  * the `ExcisionSurface`.
      61             :  *
      62             :  * \details This holds
      63             :  *
      64             :  * \f{equation}{
      65             :  * \beta^i \frac{\partial x^\hat{i}}{\partial x^i} =
      66             :  * \hat{beta}^\hat{i} + \frac{\partial x^\hat{i}}{\partial t}
      67             :  * \f}
      68             :  *
      69             :  * where hatted quantities are in the distorted frame and non-hatted quantities
      70             :  * are in the grid frame.
      71             :  */
      72             : template <typename Frame>
      73           1 : struct ShiftyQuantity {
      74           0 :   using type = tnsr::I<DataVector, 3, Frame>;
      75             : };
      76             : 
      77             : /// \ingroup ControlSystemGroup
      78             : /// Holds the spatial metric on the `ExcisionSurface`
      79             : template <typename Frame>
      80           1 : struct SpatialMetricOnExcisionSurface {
      81           0 :   using type = tnsr::ii<DataVector, 3, Frame>;
      82             : };
      83             : 
      84             : /// \ingroup ControlSystemGroup
      85             : /// Holds the inverse spatial metric on the `ExcisionSurface`
      86             : template <typename Frame>
      87           1 : struct InverseSpatialMetricOnExcisionSurface {
      88           0 :   using type = tnsr::II<DataVector, 3, Frame>;
      89             : };
      90             : 
      91             : /*!
      92             :  * \ingroup ControlSystemGroup
      93             :  * \brief A queue tag that holds a TaggedTuple of all quantities needed for the
      94             :  * excision measurement of size control.
      95             :  *
      96             :  * \details Holds the following queue tags in a TaggedTuple in order:
      97             :  *
      98             :  * - `control_system::QueueTags::ExcisionSurface`
      99             :  * - `control_system::QueueTags::LapseOnExcisionSurface`
     100             :  * - `control_system::QueueTags::ShiftyQuantity`
     101             :  * - `control_system::QueueTags::SpatialMetricOnExcisionSurface`
     102             :  * - `control_system::QueueTags::InverseSpatialMetricOnExcisionSurface`
     103             :  */
     104             : template <typename Frame>
     105           1 : struct SizeExcisionQuantities {
     106           0 :   using type =
     107             :       tuples::TaggedTuple<ExcisionSurface<Frame>, LapseOnExcisionSurface,
     108             :                           ShiftyQuantity<Frame>,
     109             :                           SpatialMetricOnExcisionSurface<Frame>,
     110             :                           InverseSpatialMetricOnExcisionSurface<Frame>>;
     111             : };
     112             : 
     113             : /*!
     114             :  * \ingroup ControlSystemGroup
     115             :  * \brief A queue tag that holds a TaggedTuple of all quantities needed for the
     116             :  * horizon measurement of size control.
     117             :  *
     118             :  * \details Holds the following queue tags in a TaggedTuple in order:
     119             :  *
     120             :  * - `ylm::Tags::Strahlkorper`
     121             :  * - `::Tags::dt<ylm::Tags::Strahlkorper>`
     122             :  */
     123             : template <typename Frame>
     124           1 : struct SizeHorizonQuantities {
     125           0 :   using type = tuples::TaggedTuple<ylm::Tags::Strahlkorper<Frame>,
     126             :                                    ::Tags::dt<ylm::Tags::Strahlkorper<Frame>>>;
     127             : };
     128             : }  // namespace control_system::QueueTags