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 <optional>
       8              : #include <ostream>
       9              : 
      10              : #include "DataStructures/DataBox/Prefixes.hpp"
      11              : #include "DataStructures/DataVector.hpp"
      12              : #include "DataStructures/Tensor/TypeAliases.hpp"
      13              : #include "DataStructures/Variables.hpp"
      14              : #include "NumericalAlgorithms/DiscontinuousGalerkin/Formulation.hpp"
      15              : #include "NumericalAlgorithms/LinearOperators/Divergence.hpp"
      16              : #include "NumericalAlgorithms/LinearOperators/PartialDerivatives.hpp"
      17              : #include "NumericalAlgorithms/Spectral/Mesh.hpp"
      18              : #include "Utilities/Gsl.hpp"
      19              : #include "Utilities/TMPL.hpp"
      20              : 
      21              : namespace evolution::dg::Actions::detail {
      22              : /*
      23              :  * Computes the volume terms for a discontinuous Galerkin scheme.
      24              :  *
      25              :  * The function does the following (in order):
      26              :  *
      27              :  * 1. Compute the partial derivatives of the `System::gradient_variables`.
      28              :  *
      29              :  *    The partial derivatives are needed in the nonconservative product terms
      30              :  *    of the evolution equations. Any variable whose evolution equation does
      31              :  *    not contain a flux must contain a nonconservative product and the
      32              :  *    variable must be listed in the `System::gradient_variables` type alias.
      33              :  *    The partial derivatives are also needed for adding the moving mesh terms
      34              :  *    to the equations that do not have a flux term.
      35              :  *
      36              :  * 2. The volume time derivatives are calculated from
      37              :  *    `System::compute_volume_time_derivative_terms`
      38              :  *
      39              :  *    The source terms and nonconservative products are contributed directly
      40              :  *    to the `dt_vars` arguments passed to the time derivative function, while
      41              :  *    the volume fluxes are computed into the `volume_fluxes` arguments. The
      42              :  *    divergence of the volume fluxes will be computed and added to the time
      43              :  *    derivatives later in the function.
      44              :  *
      45              :  * 3. If the mesh is moving the appropriate mesh velocity terms are added to
      46              :  *    the equations.
      47              :  *
      48              :  *    For equations with fluxes this means that \f$-v^i_g u_\alpha\f$ is
      49              :  *    added to the fluxes and \f$-u_\alpha \partial_i v^i_g\f$ is added
      50              :  *    to the time derivatives. For equations without fluxes
      51              :  *    \f$v^i\partial_i u_\alpha\f$ is added to the time derivatives.
      52              :  *
      53              :  * 4. Compute flux divergence contribution and add it to the time derivatives.
      54              :  *
      55              :  *    Either the weak or strong form can be used. Currently only the strong
      56              :  *    form is coded, but adding the weak form is quite easy.
      57              :  *
      58              :  *    Note that the computation of the flux divergence and adding that to the
      59              :  *    time derivative must be done *after* the mesh velocity is subtracted
      60              :  *    from the fluxes.
      61              :  */
      62              : template <typename ComputeVolumeTimeDerivativeTerms, size_t Dim,
      63              :           typename... TimeDerivativeArguments, typename... VariablesTags,
      64              :           typename... SourceVarsTags, typename... PartialDerivTags,
      65              :           typename... FluxVariablesTags, typename... TemporaryTags>
      66              : void volume_terms(
      67              :     const gsl::not_null<Variables<tmpl::list<::Tags::dt<VariablesTags>...>>*>
      68              :         dt_vars_ptr,
      69              :     [[maybe_unused]] const gsl::not_null<Variables<tmpl::list<::Tags::Flux<
      70              :         FluxVariablesTags, tmpl::size_t<Dim>, Frame::Inertial>...>>*>
      71              :         volume_fluxes,
      72              :     [[maybe_unused]] const gsl::not_null<Variables<tmpl::list<::Tags::deriv<
      73              :         PartialDerivTags, tmpl::size_t<Dim>, Frame::Inertial>...>>*>
      74              :         partial_derivs,
      75              :     [[maybe_unused]] const gsl::not_null<
      76              :         Variables<tmpl::list<TemporaryTags...>>*>
      77              :         temporaries,
      78              :     [[maybe_unused]] const gsl::not_null<
      79              :         Variables<tmpl::list<::Tags::div<::Tags::Flux<
      80              :             FluxVariablesTags, tmpl::size_t<Dim>, Frame::Inertial>>...>>*>
      81              :         div_fluxes,
      82              :     const Variables<tmpl::list<SourceVarsTags...>>& source_vars,
      83              :     const ::dg::Formulation dg_formulation, const Mesh<Dim>& mesh,
      84              :     [[maybe_unused]] const tnsr::I<DataVector, Dim, Frame::Inertial>&
      85              :         inertial_coordinates,
      86              :     const InverseJacobian<DataVector, Dim, Frame::ElementLogical,
      87              :                           Frame::Inertial>&
      88              :         logical_to_inertial_inverse_jacobian,
      89              :     [[maybe_unused]] const Scalar<DataVector>* const det_inverse_jacobian,
      90              :     const std::optional<tnsr::I<DataVector, Dim, Frame::Inertial>>&
      91              :         mesh_velocity,
      92              :     const std::optional<Scalar<DataVector>>& div_mesh_velocity,
      93              :     const TimeDerivativeArguments&... time_derivative_args);
      94              : }  // namespace evolution::dg::Actions::detail