SpECTRE Documentation Coverage Report
Current view: top level - ControlSystem/Tags - QueueTags.hpp Coverage Total Hit
Commit: 0d1d717af84a81fb1284a20c4013708fe85cc2f0 Lines: 50.0 % 28 14
Test Date: 2026-10-22 17:29:42
Legend: Lines:     hit not hit

            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/TaggedTuple.hpp"
       8              : #include "DataStructures/Tensor/TypeAliases.hpp"
       9              : #include "NumericalAlgorithms/Strahlkorper/Tags.hpp"
      10              : #include "PointwiseFunctions/GeneralRelativity/Tags.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
        

Generated by: LCOV version 2.0-1