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/PrefixHelpers.hpp"
       9              : #include "DataStructures/DataBox/Prefixes.hpp"
      10              : #include "DataStructures/DataBox/Tag.hpp"
      11              : #include "DataStructures/DataVector.hpp"
      12              : #include "DataStructures/SliceVariables.hpp"
      13              : #include "Domain/Structure/Element.hpp"
      14              : #include "Domain/Structure/IndexToSliceAt.hpp"
      15              : #include "Domain/Tags.hpp"
      16              : #include "Domain/Tags/FaceNormal.hpp"
      17              : #include "Domain/Tags/Faces.hpp"
      18              : #include "NumericalAlgorithms/DiscontinuousGalerkin/NormalDotFlux.hpp"
      19              : #include "NumericalAlgorithms/Spectral/Mesh.hpp"
      20              : #include "NumericalAlgorithms/Spectral/Quadrature.hpp"
      21              : #include "Utilities/ErrorHandling/Assert.hpp"
      22              : #include "Utilities/Gsl.hpp"
      23              : #include "Utilities/TMPL.hpp"
      24              : 
      25              : namespace elliptic::Tags {
      26              : 
      27              : /// The `FieldsTag` on external boundaries
      28              : template <size_t Dim, typename FieldsTag>
      29            1 : struct BoundaryFieldsCompute : db::ComputeTag,
      30              :                                domain::Tags::Faces<Dim, FieldsTag> {
      31            0 :   using base = domain::Tags::Faces<Dim, FieldsTag>;
      32            0 :   using return_type = typename base::type;
      33            0 :   using argument_tags = tmpl::list<FieldsTag, domain::Tags::Mesh<Dim>,
      34              :                                    domain::Tags::Element<Dim>>;
      35            0 :   static void function(const gsl::not_null<return_type*> vars_on_face,
      36              :                        const typename FieldsTag::type& vars,
      37              :                        const Mesh<Dim>& mesh, const Element<Dim>& element) {
      38              :     ASSERT(mesh.quadrature(0) == Spectral::Quadrature::GaussLobatto,
      39              :            "Slicing fields to the boundary currently supports only "
      40              :            "Gauss-Lobatto grids. Add support to "
      41              :            "'elliptic::Tags::BoundaryFieldsCompute'.");
      42              :     for (const auto& direction : element.external_boundaries()) {
      43              :       data_on_slice(make_not_null(&((*vars_on_face)[direction])), vars,
      44              :                     mesh.extents(), direction.dimension(),
      45              :                     index_to_slice_at(mesh.extents(), direction));
      46              :     }
      47              :   }
      48              : };
      49              : 
      50              : /// The `::Tags::NormalDotFlux<FieldsTag>` on external boundaries
      51              : template <size_t Dim, typename FieldsTag, typename FluxesTag>
      52            1 : struct BoundaryFluxesCompute
      53              :     : db::ComputeTag,
      54              :       domain::Tags::Faces<
      55              :           Dim, db::add_tag_prefix<::Tags::NormalDotFlux, FieldsTag>> {
      56            0 :   using base =
      57              :       domain::Tags::Faces<Dim,
      58              :                           db::add_tag_prefix<::Tags::NormalDotFlux, FieldsTag>>;
      59            0 :   using return_type = typename base::type;
      60            0 :   using argument_tags =
      61              :       tmpl::list<FluxesTag,
      62              :                  domain::Tags::Faces<Dim, domain::Tags::FaceNormal<Dim>>,
      63              :                  domain::Tags::Mesh<Dim>, domain::Tags::Element<Dim>>;
      64            0 :   static void function(
      65              :       const gsl::not_null<return_type*> normal_dot_fluxes,
      66              :       const typename FluxesTag::type& fluxes,
      67              :       const DirectionMap<Dim, tnsr::i<DataVector, Dim>>& face_normals,
      68              :       const Mesh<Dim>& mesh, const Element<Dim>& element) {
      69              :     ASSERT(mesh.quadrature(0) == Spectral::Quadrature::GaussLobatto,
      70              :            "Slicing fluxes to the boundary currently supports only "
      71              :            "Gauss-Lobatto grids. Add support to "
      72              :            "'elliptic::Tags::BoundaryFluxesCompute'.");
      73              :     for (const auto& direction : element.external_boundaries()) {
      74              :       const auto fluxes_on_face =
      75              :           data_on_slice(fluxes, mesh.extents(), direction.dimension(),
      76              :                         index_to_slice_at(mesh.extents(), direction));
      77              :       normal_dot_flux(make_not_null(&((*normal_dot_fluxes)[direction])),
      78              :                       face_normals.at(direction), fluxes_on_face);
      79              :     }
      80              :   }
      81              : };
      82              : 
      83              : }  // namespace elliptic::Tags