Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <array>
       7             : #include <cstddef>
       8             : 
       9             : #include "DataStructures/Tensor/TypeAliases.hpp"
      10             : #include "NumericalAlgorithms/LinearOperators/PartialDerivatives.hpp"
      11             : #include "Utilities/Gsl.hpp"
      12             : 
      13             : /// \cond
      14             : class DataVector;
      15             : template <size_t Dim, typename T>
      16             : class DirectionMap;
      17             : template <size_t Dim>
      18             : class Mesh;
      19             : template <typename TagsList>
      20             : class Variables;
      21             : /// \endcond
      22             : 
      23             : namespace fd {
      24             : /*!
      25             :  * \ingroup NumericalAlgorithmsGroup
      26             :  * \brief Compute the logical partial derivatives using cell-centered finite
      27             :  * difference derivatives.
      28             :  *
      29             :  * Up to 8th order stencils are supported.
      30             :  *
      31             :  * \note Currently the stride is always one because we transpose the data before
      32             :  * reconstruction. However, it may be faster to have a non-unit stride without
      33             :  * the transpose. We have the `stride` parameter in the derivative stencils
      34             :  * to make testing performance easier in the future.
      35             :  *
      36             :  * \note This code does not do any explicit SIMD vectorization. We will want to
      37             :  * profile and decide if optimization are possible. The Vc SIMD library has an
      38             :  * example of vectorizing single-precision FD derivatives. There is also a paper
      39             :  * "Optimization of Finite-Differencing Kernels for Numerical Relativity
      40             :  * Applications" by Alfieri, Bernuzzi, Perego, and Radice that uses compiler
      41             :  * auto-vectorization.
      42             :  */
      43             : template <size_t Dim>
      44           1 : void logical_partial_derivatives(
      45             :     const gsl::not_null<std::array<gsl::span<double>, Dim>*>
      46             :         logical_derivatives,
      47             :     const gsl::span<const double>& volume_vars,
      48             :     const DirectionMap<Dim, gsl::span<const double>>& ghost_cell_vars,
      49             :     const Mesh<Dim>& volume_mesh, size_t number_of_variables, size_t fd_order);
      50             : 
      51             : /*!
      52             :  * \ingroup NumericalAlgorithmsGroup
      53             :  * \brief Compute the partial derivative on the `DerivativeFrame` using the
      54             :  * `inverse_jacobian`.
      55             :  *
      56             :  * Logical partial derivatives are first computed using the
      57             :  * `fd::logical_partial_derivatives()` function.
      58             :  */
      59             : template <typename DerivativeTags, size_t Dim, typename DerivativeFrame>
      60           1 : void partial_derivatives(
      61             :     gsl::not_null<Variables<db::wrap_tags_in<
      62             :         Tags::deriv, DerivativeTags, tmpl::size_t<Dim>, DerivativeFrame>>*>
      63             :         d_volume_vars,
      64             :     const gsl::span<const double>& volume_vars,
      65             :     const DirectionMap<Dim, gsl::span<const double>>& ghost_cell_vars,
      66             :     const Mesh<Dim>& volume_mesh, size_t number_of_variables, size_t fd_order,
      67             :     const InverseJacobian<DataVector, Dim, Frame::ElementLogical,
      68             :                           DerivativeFrame>& inverse_jacobian);
      69             : /*!
      70             :  * \ingroup NumericalAlgorithmsGroup
      71             :  * \brief Compute the partial derivative using the `inverse_jacobian` for
      72             :  * `Basis::FiniteDifference` dimensions and the Cartoon method for
      73             :  * `Basis::Cartoon` dimensions.
      74             :  *
      75             :  * See DG `cartoon_partial_derivatives()` for information on the Cartoon method.
      76             :  */
      77             : template <typename DerivativeTags, typename VariableTags, size_t Dim,
      78             :           typename DerivativeFrame, Requires<Dim == 3> = nullptr>
      79           1 : void cartoon_partial_derivatives(
      80             :     gsl::not_null<Variables<db::wrap_tags_in<
      81             :         Tags::deriv, DerivativeTags, tmpl::size_t<Dim>, DerivativeFrame>>*>
      82             :         d_volume_vars,
      83             :     const Variables<VariableTags>& volume_vars,
      84             :     const DirectionMap<Dim, gsl::span<const double>>& ghost_cell_vars,
      85             :     const Mesh<Dim>& volume_mesh, size_t number_of_variables, size_t fd_order,
      86             :     const InverseJacobian<DataVector, Dim, Frame::ElementLogical,
      87             :                           DerivativeFrame>& inverse_jacobian,
      88             :     const tnsr::I<DataVector, Dim, Frame::Inertial>& inertial_coords);
      89             : 
      90             : /*!
      91             :  * \ingroup NumericalAlgorithmsGroup
      92             :  * \brief Compute the partial derivative, either normal FD or FD/cartoon,
      93             :  * based on the mesh (only known at runtime).
      94             :  */
      95             : template <typename DerivativeTags, typename VariableTags, size_t Dim,
      96             :           typename DerivativeFrame>
      97           1 : void partial_derivatives(
      98             :     gsl::not_null<Variables<db::wrap_tags_in<
      99             :         Tags::deriv, DerivativeTags, tmpl::size_t<Dim>, DerivativeFrame>>*>
     100             :         d_volume_vars,
     101             :     const Variables<VariableTags>& volume_vars,
     102             :     const DirectionMap<Dim, gsl::span<const double>>& ghost_cell_vars,
     103             :     const Mesh<Dim>& volume_mesh, size_t number_of_variables, size_t fd_order,
     104             :     const InverseJacobian<DataVector, Dim, Frame::ElementLogical,
     105             :                           DerivativeFrame>& inverse_jacobian,
     106             :     const tnsr::I<DataVector, Dim, Frame::Inertial>& inertial_coords);
     107             : 
     108             : }  // namespace fd