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 "PointwiseFunctions/GeneralRelativity/Tags.hpp"
      10             : #include "Utilities/TaggedTuple.hpp"
      11             : 
      12             : /// \cond
      13             : class DataVector;
      14             : namespace ylm {
      15             : template <typename Frame>
      16             : class Strahlkorper;
      17             : }  // namespace ylm
      18             : namespace domain {
      19             : enum class ObjectLabel;
      20             : }  // namespace domain
      21             : /// \endcond
      22             : 
      23             : /// \ingroup ControlSystemGroup
      24             : /// All tags that will be used in the LinkedMessageQueue's within control
      25             : /// systems.
      26             : ///
      27             : /// These tags will be used to retrieve the results of the measurements that
      28             : /// were sent to the control system which have been placed inside a
      29             : /// LinkedMessageQueue.
      30           1 : namespace control_system::QueueTags {
      31             : /// \ingroup ControlSystemGroup
      32             : /// Holds the centers of each horizon from measurements as DataVectors
      33             : template <::domain::ObjectLabel Horizon, typename = Frame::Grid>
      34           1 : struct Center {
      35           0 :   using type = DataVector;
      36             : };
      37             : 
      38             : /// \ingroup ControlSystemGroup
      39             : /// Holds a full strahlkorper from measurements that represents a horizon
      40             : template <typename Frame, ::domain::ObjectLabel Object>
      41           1 : struct Horizon {
      42           0 :   using type = ylm::Strahlkorper<Frame>;
      43             : };
      44             : 
      45             : /// \ingroup ControlSystemGroup
      46             : /// Holds a full strahlkorper from measurements for the excision surface
      47             : template <typename Frame>
      48           1 : struct ExcisionSurface {
      49           0 :   using type = ylm::Strahlkorper<Frame>;
      50             : };
      51             : 
      52             : /// \ingroup ControlSystemGroup
      53             : /// Holds the lapse on the `ExcisionSurface`
      54           1 : struct LapseOnExcisionSurface {
      55           0 :   using type = Scalar<DataVector>;
      56             : };
      57             : 
      58             : /*!
      59             :  * \ingroup ControlSystemGroup
      60             :  * \brief Holds a quantity that's similar to the shift, but isn't the shift, on
      61             :  * the `ExcisionSurface`.
      62             :  *
      63             :  * \details This holds
      64             :  *
      65             :  * \f{equation}{
      66             :  * \beta^i \frac{\partial x^\hat{i}}{\partial x^i} =
      67             :  * \hat{beta}^\hat{i} + \frac{\partial x^\hat{i}}{\partial t}
      68             :  * \f}
      69             :  *
      70             :  * where hatted quantities are in the distorted frame and non-hatted quantities
      71             :  * are in the grid frame.
      72             :  */
      73             : template <typename Frame>
      74           1 : struct ShiftyQuantity {
      75           0 :   using type = tnsr::I<DataVector, 3, Frame>;
      76             : };
      77             : 
      78             : /// \ingroup ControlSystemGroup
      79             : /// Holds the spatial metric on the `ExcisionSurface`
      80             : template <typename Frame>
      81           1 : struct SpatialMetricOnExcisionSurface {
      82           0 :   using type = tnsr::ii<DataVector, 3, Frame>;
      83             : };
      84             : 
      85             : /// \ingroup ControlSystemGroup
      86             : /// Holds the inverse spatial metric on the `ExcisionSurface`
      87             : template <typename Frame>
      88           1 : struct InverseSpatialMetricOnExcisionSurface {
      89           0 :   using type = tnsr::II<DataVector, 3, Frame>;
      90             : };
      91             : 
      92             : /// \ingroup ControlSystemGroup
      93             : /// Holds the spatial christoffel symbol on the `ExcisionSurface`
      94             : template <typename Frame>
      95           1 : struct SpatialChristoffelSecondKind {
      96           0 :   using type = tnsr::Ijj<DataVector, 3, Frame>;
      97             : };
      98             : 
      99             : /// \ingroup ControlSystemGroup
     100             : /// Holds the spatial derivative of the lapse on the `ExcisionSurface`
     101             : template <typename Frame>
     102           1 : struct DerivLapse {
     103           0 :   using type = tnsr::i<DataVector, 3, Frame>;
     104             : };
     105             : 
     106             : /// \ingroup ControlSystemGroup
     107             : /// Holds the spatial derivative of the `Frame` shift on the `ExcisionSurface`
     108             : template <typename Frame>
     109           1 : struct DerivShift {
     110           0 :   using type = tnsr::iJ<DataVector, 3, Frame>;
     111             : };
     112             : 
     113             : /// \ingroup ControlSystemGroup
     114             : /// Holds the inverse jacobian between frames on the `ExcisionSurface`
     115             : template <typename SrcFrame, typename DestFrame>
     116           1 : struct InverseJacobian {
     117           0 :   using type = ::InverseJacobian<DataVector, 3, SrcFrame, DestFrame>;
     118             : };
     119             : 
     120             : /*!
     121             :  * \ingroup ControlSystemGroup
     122             :  * \brief A queue tag that holds a TaggedTuple of all quantities needed for the
     123             :  * excision measurement of size control.
     124             :  *
     125             :  * \details Holds the following queue tags in a TaggedTuple in order:
     126             :  *
     127             :  * - `control_system::QueueTags::ExcisionSurface`
     128             :  * - `control_system::QueueTags::LapseOnExcisionSurface`
     129             :  * - `control_system::QueueTags::ShiftyQuantity`
     130             :  * - `control_system::QueueTags::SpatialMetricOnExcisionSurface`
     131             :  * - `control_system::QueueTags::InverseSpatialMetricOnExcisionSurface`
     132             :  * - `control_system::QueueTags::SpatialChristoffelSecondKind`
     133             :  * - `control_system::QueueTags::DerivLapse`
     134             :  * - `control_system::QueueTags::DerivShift`
     135             :  * - `control_system::QueueTags::InverseJacobian<::Frame::Grid, Frame>`
     136             :  */
     137             : template <typename Frame>
     138           1 : struct SizeExcisionQuantities {
     139           0 :   using type = tuples::TaggedTuple<
     140             :       ExcisionSurface<Frame>, LapseOnExcisionSurface, ShiftyQuantity<Frame>,
     141             :       SpatialMetricOnExcisionSurface<Frame>,
     142             :       InverseSpatialMetricOnExcisionSurface<Frame>,
     143             :       SpatialChristoffelSecondKind<Frame>, DerivLapse<Frame>, DerivShift<Frame>,
     144             :       InverseJacobian<::Frame::Grid, Frame>>;
     145             : };
     146             : 
     147             : /*!
     148             :  * \ingroup ControlSystemGroup
     149             :  * \brief A queue tag that holds a TaggedTuple of all quantities needed for the
     150             :  * horizon measurement of size control.
     151             :  *
     152             :  * \details Holds the following queue tags in a TaggedTuple in order:
     153             :  *
     154             :  * - `ylm::Tags::Strahlkorper`
     155             :  * - `::Tags::dt<ylm::Tags::Strahlkorper>`
     156             :  */
     157             : template <typename Frame>
     158           1 : struct SizeHorizonQuantities {
     159           0 :   using type = tuples::TaggedTuple<ylm::Tags::Strahlkorper<Frame>,
     160             :                                    ::Tags::dt<ylm::Tags::Strahlkorper<Frame>>>;
     161             : };
     162             : }  // namespace control_system::QueueTags