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              : #include <iosfwd>
       8              : #include <optional>
       9              : #include <pup.h>
      10              : #include <string>
      11              : #include <utility>
      12              : 
      13              : #include "DataStructures/DataVector.hpp"
      14              : #include "DataStructures/Tensor/Tensor.hpp"
      15              : #include "NumericalAlgorithms/Spectral/Mesh.hpp"
      16              : #include "Utilities/Gsl.hpp"
      17              : #include "Utilities/Serialization/PupStlCpp17.hpp"
      18              : 
      19              : namespace evolution::dg {
      20              : /*!
      21              :  * \brief Data on the mortar used to compute the boundary correction for the
      22              :  * DG scheme.
      23              :  *
      24              :  * The class holds the data that has been projected to one side of the mortar.
      25              :  * It is meant to be used in a container (either MortarDataHolder or
      26              :  * TimeSteppers::BoundaryHistory) that holds MortarData on each side of the
      27              :  * mortar. The data is later used to compute the same unique boundary correction
      28              :  * on the mortar for both elements. That is, the final boundary correction
      29              :  * computation is done twice: once on each element touching the mortar. However,
      30              :  * the computation is done in such a way that the results agree.
      31              :  *
      32              :  * For local time stepping, the magnitude of the face normal is stored.
      33              :  *
      34              :  * The magnitude of the face normal is given by:
      35              :  *
      36              :  * \f{align*}{
      37              :  *  \sqrt{
      38              :  *   \frac{\partial\xi}{\partial x^i} \gamma^{ij}
      39              :  *   \frac{\partial\xi}{\partial x^j}}
      40              :  * \f}
      41              :  *
      42              :  * for a face in the \f$\xi\f$-direction, with inverse spatial metric
      43              :  * \f$\gamma^{ij}\f$.
      44              :  *
      45              :  * In addition, for local time stepping with Gauss points, the determinants of
      46              :  * the volume inverse Jacobian and the face Jacobian are stored.
      47              :  *
      48              :  * In addition to the (type-erased) fields on the mortar, the appropriate meshes
      49              :  * are stored.  When setting the mortar data and mortar mesh, the face mesh
      50              :  * should also be set as it is used when hybridizing DG with finite difference
      51              :  * or finite volume schemes (DG-subcell).
      52              :  *
      53              :  * If the element and its neighbor have unaligned logical coordinate
      54              :  * systems then the data and meshes are stored in the local logical
      55              :  * coordinate's orientation (\f$\xi\f$ varies fastest). This means the
      56              :  * action sending the data is responsible for reorienting the data on
      57              :  * the mortar so it matches the neighbor's orientation.
      58              :  *
      59              :  * \tparam Dim the volume dimension
      60              :  */
      61              : template <size_t Dim>
      62            1 : struct MortarData {
      63            0 :   std::optional<DataVector> mortar_data{std::nullopt};
      64            0 :   std::optional<Scalar<DataVector>> face_normal_magnitude{std::nullopt};
      65            0 :   std::optional<Scalar<DataVector>> face_det_jacobian{std::nullopt};
      66            0 :   std::optional<Scalar<DataVector>> volume_det_inv_jacobian{std::nullopt};
      67            0 :   std::optional<Mesh<Dim - 1>> mortar_mesh{std::nullopt};
      68            0 :   std::optional<Mesh<Dim - 1>> face_mesh{std::nullopt};
      69            0 :   std::optional<Mesh<Dim>> volume_mesh{std::nullopt};
      70              : 
      71              :   // NOLINTNEXTLINE(google-runtime-references)
      72            0 :   void pup(PUP::er& p);
      73              : };
      74              : 
      75              : /// \brief Projects the geometric data (but not the data on the mortar
      76              : /// grid) when p-refined
      77              : ///
      78              : /// \details only updates the stored mesh if the corresponding data exists
      79              : ///
      80              : /// \note The DG-subcell code stores the face mesh in the MortarData even when
      81              : /// the geometric data are not used.  Currently projection of MortarData is only
      82              : ///  needed for local time-stepping which is not yet supported for DG-subcell.
      83              : ///
      84              : /// \returns If the data was modified
      85              : template <size_t Dim>
      86            1 : bool p_project_geometric_data(
      87              :     gsl::not_null<::evolution::dg::MortarData<Dim>*> mortar_data,
      88              :     const Mesh<Dim - 1>& new_face_mesh, const Mesh<Dim>& new_volume_mesh);
      89              : 
      90              : /// \brief Projects the mortar data (but not the geometric data) when p-refined
      91              : ///
      92              : /// \details Used to re-project mortar data when the mortar mesh changes
      93              : /// reactively after the neighbor face mesh is received.  In this case, the
      94              : /// geometric data does not need to be updated as it already used the correct
      95              : /// face/volume mesh.
      96              : ///
      97              : /// \returns If the data was modified
      98              : template <size_t Dim>
      99            1 : bool p_project_mortar_data(
     100              :     gsl::not_null<::evolution::dg::MortarData<Dim>*> mortar_data,
     101              :     const Mesh<Dim - 1>& new_mortar_mesh);
     102              : 
     103              : template <size_t Dim>
     104            0 : bool operator==(const MortarData<Dim>& lhs, const MortarData<Dim>& rhs);
     105              : 
     106              : template <size_t Dim>
     107            0 : bool operator!=(const MortarData<Dim>& lhs, const MortarData<Dim>& rhs);
     108              : 
     109              : template <size_t Dim>
     110            0 : std::ostream& operator<<(std::ostream& os, const MortarData<Dim>& mortar_data);
     111              : }  // namespace evolution::dg