Line data    Source code

       1            1 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : /// \file
       5              : /// Defines functions logical_coordinates and interface_logical_coordinates
       6              : 
       7              : #pragma once
       8              : 
       9              : #include <cstddef>
      10              : 
      11              : #include "DataStructures/DataBox/Tag.hpp"
      12              : #include "DataStructures/Tensor/TypeAliases.hpp"
      13              : #include "Utilities/TMPL.hpp"
      14              : 
      15              : /// \cond
      16              : namespace domain {
      17              : namespace Tags {
      18              : template<size_t Dim>
      19              : struct Mesh;
      20              : template <size_t, typename>
      21              : struct Coordinates;
      22              : }  // namespace Tags
      23              : }  // namespace domain
      24              : 
      25              : template <size_t Dim>
      26              : class Mesh;
      27              : class DataVector;
      28              : template <size_t Dim>
      29              : class Direction;
      30              : 
      31              : namespace gsl {
      32              : template <typename>
      33              : struct not_null;
      34              : }  // namespace gsl
      35              : /// \endcond
      36              : 
      37              : /// @{
      38              : /*!
      39              :  * \ingroup ComputationalDomainGroup
      40              :  * \brief Compute the logical coordinates of a Mesh in an Element.
      41              :  *
      42              :  * \details The logical coordinates are the collocation points
      43              :  * associated with the Spectral::Basis and Spectral::Quadrature of the \p mesh.
      44              :  * The Spectral::Basis determines the domain of the logical coordinates, while
      45              :  * the Spectral::Quadrature determines their distribution.  For Legendre or
      46              :  * Chebyshev bases, the logical coordinates are in the interval \f$[-1, 1]\f$.
      47              :  * These bases may have either GaussLobatto or Gauss quadrature, which are not
      48              :  * uniformly distributed, and either include (GaussLobatto) or do not include
      49              :  * (Gauss) the end points.  For the FiniteDifference basis, the logical
      50              :  * coordinates are again in the interval \f$[-1, 1]\f$.  This basis may have
      51              :  * either FaceCentered or CellCentered quadrature, which are uniformly
      52              :  * distributed, and either include (FaceCentered) or do not include
      53              :  * (CellCentered) the end points. The Fourier basis has logical coordinates
      54              :  * in the interval \f$[0, 2 \pi]\f$. The SphericalHarmonic basis corresponds to
      55              :  * the spherical coordinates \f$(\theta, \phi)\f$ where the polar angle
      56              :  * \f$\theta\f$ is in the interval \f$[0, \pi]\f$ and the azimuth \f$\phi\f$ is
      57              :  * in the interval \f$[0, 2 \pi]\f$.  The polar angle has Gauss quadrature
      58              :  * corresponding to the Legendre Gauss points of \f$\cos \theta\f$ (and thus
      59              :  * have no points at the poles), while the azimuth has Equiangular quadrature
      60              :  * which are distributed uniformly including the left endpoint, but not the
      61              :  * right. For the Cartoon basis, only one logical coordinate is allowed and it
      62              :  * is never used for computations. The Zernike bases have the radial basis
      63              :  * implemented such that the logical coordinates are \f$[-1, 1]\f$, while
      64              :  * an affine map is internally used to go to \f$[0, 1]\f$, where these bases are
      65              :  * defined. Being a scaled one-sided Jacobi polynomial, the gridpoint are
      66              :  * shifted to upper \f$r\f$, and GaussRadauUpper quadrature has been implemented
      67              :  * such that the lower edge does not have an end point but the upper does.
      68              :  *
      69              :  * \example
      70              :  * \snippet Test_LogicalCoordinates.cpp logical_coordinates_example
      71              :  */
      72              : template <size_t VolumeDim>
      73            1 : void logical_coordinates(
      74              :     gsl::not_null<tnsr::I<DataVector, VolumeDim, Frame::ElementLogical>*>
      75              :         logical_coords,
      76              :     const Mesh<VolumeDim>& mesh);
      77              : 
      78              : template <size_t VolumeDim>
      79            1 : tnsr::I<DataVector, VolumeDim, Frame::ElementLogical> logical_coordinates(
      80              :     const Mesh<VolumeDim>& mesh);
      81              : /// @}
      82              : 
      83              : namespace domain {
      84              : namespace Tags {
      85              : /// \ingroup DataBoxTagsGroup
      86              : /// \ingroup ComputationalDomainGroup
      87              : /// The logical coordinates in the Element
      88              : template <size_t VolumeDim>
      89            1 : struct LogicalCoordinates : Coordinates<VolumeDim, Frame::ElementLogical>,
      90              :                             db::ComputeTag {
      91            0 :   using base = Coordinates<VolumeDim, Frame::ElementLogical>;
      92            0 :   using return_type = typename base::type;
      93            0 :   using argument_tags = tmpl::list<Mesh<VolumeDim>>;
      94            0 :   static constexpr auto function = static_cast<void (*)(
      95              :       gsl::not_null<return_type*>, const ::Mesh<VolumeDim>&)>(
      96              :       &logical_coordinates<VolumeDim>);
      97              : };
      98              : }  // namespace Tags
      99              : }  // namespace domain