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             : 
       8             : #include "DataStructures/DataBox/Prefixes.hpp"
       9             : #include "DataStructures/DataBox/Tag.hpp"
      10             : #include "DataStructures/DataVector.hpp"
      11             : #include "DataStructures/Tensor/EagerMath/DotProduct.hpp"
      12             : #include "DataStructures/Tensor/Tensor.hpp"
      13             : #include "Domain/FunctionsOfTime/Tags.hpp"
      14             : #include "Evolution/Systems/GeneralizedHarmonic/ConstraintDamping/Tags.hpp"
      15             : #include "Evolution/Systems/GeneralizedHarmonic/Tags.hpp"
      16             : #include "PointwiseFunctions/GeneralRelativity/Tags.hpp"
      17             : #include "Utilities/ContainerHelpers.hpp"
      18             : #include "Utilities/Gsl.hpp"
      19             : #include "Utilities/TMPL.hpp"
      20             : 
      21             : /// \cond
      22             : namespace Tags {
      23             : struct Time;
      24             : }  // namespace Tags
      25             : namespace domain {
      26             : namespace Tags {
      27             : template <size_t Dim, typename Frame>
      28             : struct Coordinates;
      29             : }  // namespace Tags
      30             : }  // namespace domain
      31             : class DataVector;
      32             : template <typename X, typename Symm, typename IndexList>
      33             : class Tensor;
      34             : /// \endcond
      35             : 
      36             : namespace gh::ConstraintDamping::Tags {
      37             : /*!
      38             :  * \brief Computes the constraint damping parameter \f$\gamma_0\f$ from the
      39             :  * coordinates and a DampingFunction.
      40             :  *
      41             :  * \details Can be retrieved using
      42             :  * `gh::ConstraintDamping::Tags::ConstraintGamma0`.
      43             :  */
      44             : template <size_t SpatialDim, typename Frame>
      45           1 : struct ConstraintGamma0Compute : ConstraintGamma0, db::ComputeTag {
      46           0 :   using argument_tags =
      47             :       tmpl::list<DampingFunctionGamma0<SpatialDim, Frame>,
      48             :                  domain::Tags::Coordinates<SpatialDim, Frame>, ::Tags::Time,
      49             :                  ::domain::Tags::FunctionsOfTime>;
      50           0 :   using return_type = Scalar<DataVector>;
      51             : 
      52           0 :   static constexpr void function(
      53             :       const gsl::not_null<Scalar<DataVector>*> gamma,
      54             :       const ::gh::ConstraintDamping::DampingFunction<SpatialDim, Frame>&
      55             :           damping_function,
      56             :       const tnsr::I<DataVector, SpatialDim, Frame>& coords, const double time,
      57             :       const std::unordered_map<
      58             :           std::string,
      59             :           std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>>&
      60             :           functions_of_time) {
      61             :     damping_function(gamma, coords, time, functions_of_time);
      62             :   }
      63             : 
      64           0 :   using base = ConstraintGamma0;
      65             : };
      66             : 
      67             : /*!
      68             :  * \brief Computes the constraint damping parameter \f$\gamma_1\f$ from the
      69             :  * coordinates and a DampingFunction.
      70             :  *
      71             :  * \details Can be retrieved using
      72             :  * `gh::ConstraintDamping::Tags::ConstraintGamma1`.
      73             :  */
      74             : template <size_t SpatialDim, typename Frame>
      75           1 : struct ConstraintGamma1Compute : ConstraintGamma1, db::ComputeTag {
      76           0 :   using argument_tags =
      77             :       tmpl::list<DampingFunctionGamma1<SpatialDim, Frame>,
      78             :                  domain::Tags::Coordinates<SpatialDim, Frame>, ::Tags::Time,
      79             :                  ::domain::Tags::FunctionsOfTime>;
      80           0 :   using return_type = Scalar<DataVector>;
      81             : 
      82           0 :   static constexpr void function(
      83             :       const gsl::not_null<Scalar<DataVector>*> gamma1,
      84             :       const ::gh::ConstraintDamping::DampingFunction<SpatialDim, Frame>&
      85             :           damping_function,
      86             :       const tnsr::I<DataVector, SpatialDim, Frame>& coords, const double time,
      87             :       const std::unordered_map<
      88             :           std::string,
      89             :           std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>>&
      90             :           functions_of_time) {
      91             :     damping_function(gamma1, coords, time, functions_of_time);
      92             :   }
      93             : 
      94           0 :   using base = ConstraintGamma1;
      95             : };
      96             : 
      97             : /*!
      98             :  * \brief Computes the constraint damping parameter \f$\gamma_2\f$ from the
      99             :  * coordinates and a DampingFunction.
     100             :  *
     101             :  * \details Can be retrieved using
     102             :  * `gh::ConstraintDamping::Tags::ConstraintGamma2`.
     103             :  */
     104             : template <size_t SpatialDim, typename Frame>
     105           1 : struct ConstraintGamma2Compute : ConstraintGamma2, db::ComputeTag {
     106           0 :   using argument_tags =
     107             :       tmpl::list<DampingFunctionGamma2<SpatialDim, Frame>,
     108             :                  domain::Tags::Coordinates<SpatialDim, Frame>, ::Tags::Time,
     109             :                  ::domain::Tags::FunctionsOfTime>;
     110           0 :   using return_type = Scalar<DataVector>;
     111             : 
     112           0 :   static constexpr void function(
     113             :       const gsl::not_null<Scalar<DataVector>*> gamma,
     114             :       const ::gh::ConstraintDamping::DampingFunction<SpatialDim, Frame>&
     115             :           damping_function,
     116             :       const tnsr::I<DataVector, SpatialDim, Frame>& coords, const double time,
     117             :       const std::unordered_map<
     118             :           std::string,
     119             :           std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>>&
     120             :           functions_of_time) {
     121             :     damping_function(gamma, coords, time, functions_of_time);
     122             :   }
     123             : 
     124           0 :   using base = ConstraintGamma2;
     125             : };
     126             : }  // namespace gh::ConstraintDamping::Tags