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 "Evolution/Systems/Cce/Tags.hpp"
       9             : #include "NumericalAlgorithms/Spectral/Basis.hpp"
      10             : #include "NumericalAlgorithms/Spectral/Quadrature.hpp"
      11             : #include "NumericalAlgorithms/SpinWeightedSphericalHarmonics/SwshCollocation.hpp"
      12             : #include "Utilities/Gsl.hpp"
      13             : 
      14             : namespace Cce {
      15             : /*!
      16             :  * \brief Computes the partial derivative along a particular direction
      17             :  * determined by the `dimension_to_differentiate`.
      18             :  * The input `u` is differentiated with the spectral matrix and the solution is
      19             :  * placed in `d_u`.
      20             :  *
      21             :  * \note This is placed in Cce Utilities for its currently narrow use-case. If
      22             :  * more general uses desire a single partial derivative of complex values, this
      23             :  * should be moved to `NumericalAlgorithms`. This utility currently assumes the
      24             :  * spatial dimensionality is 3, which would also need to be generalized, likely
      25             :  * by creating a wrapping struct with partial template specializations.
      26             :  */
      27           1 : void logical_partial_directional_derivative_of_complex(
      28             :     gsl::not_null<ComplexDataVector*> d_u, const ComplexDataVector& u,
      29             :     const Mesh<3>& mesh, size_t dimension_to_differentiate);
      30             : 
      31             : namespace Tags {
      32             : /*!
      33             :  * \brief Compute tag for a manually-handled partial y derivative in the volume.
      34             :  *
      35             :  * \details Most of the partial y derivatives are handled by PreSwshDerivatives.
      36             :  * However, that infrastructure is specific to the CCE evolution system itself,
      37             :  * so it won't work for other uses (e.g. observers that are invoked
      38             :  * periodically). This compute tag instead manually computes a partial
      39             :  * y derivative.
      40             :  */
      41             : template <typename Tag>
      42           1 : struct DyCompute
      43             :     : Dy<Tag>, db::ComputeTag {
      44           0 :   using base = Dy<Tag>;
      45           0 :   using return_type = typename base::type;
      46             : 
      47           0 :   using argument_tags = tmpl::list<Tag, Tags::LMax>;
      48             : 
      49           0 :   static constexpr auto function(
      50             :       const gsl::not_null<
      51             :           Scalar<SpinWeighted<ComplexDataVector, Tag::type::type::spin>>*>
      52             :           dy_val,
      53             :       const Scalar<SpinWeighted<ComplexDataVector, Tag::type::type::spin>>& val,
      54             :       const size_t l_max) {
      55             :     if (get(*dy_val).size() != get(val).size()) {
      56             :       get(*dy_val).destructive_resize(get(val).size());
      57             :     };
      58             :     logical_partial_directional_derivative_of_complex(
      59             :         make_not_null(&get(*dy_val).data()), get(val).data(),
      60             :         Mesh<3>{
      61             :             {{Spectral::Swsh::number_of_swsh_theta_collocation_points(l_max),
      62             :               Spectral::Swsh::number_of_swsh_phi_collocation_points(l_max),
      63             :               get(val).size() /
      64             :                   Spectral::Swsh::number_of_swsh_collocation_points(l_max)}},
      65             :             Spectral::Basis::Legendre,
      66             :             Spectral::Quadrature::GaussLobatto},
      67             :         // 2 for differentiating in y; coordinate ordering is:
      68             :         // {\phi, \theta, y}.
      69             :         2);
      70             :   }
      71             : };
      72             : 
      73             : }  // namespace Tags
      74             : 
      75             : }  // namespace Cce