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 <memory>
       8              : #include <string>
       9              : #include <unordered_map>
      10              : 
      11              : #include "DataStructures/Tensor/TypeAliases.hpp"
      12              : 
      13              : /// \cond
      14              : class DataVector;
      15              : template <size_t Dim>
      16              : class Index;
      17              : template <size_t Dim, typename Frame>
      18              : class ElementMap;
      19              : namespace gsl {
      20              : template <typename T>
      21              : class not_null;
      22              : }  // namespace gsl
      23              : namespace Frame {
      24              : struct Inertial;
      25              : struct Grid;
      26              : }  // namespace Frame
      27              : namespace domain {
      28              : template <typename SourceFrame, typename TargetFrame, size_t Dim>
      29              : class CoordinateMapBase;
      30              : namespace FunctionsOfTime {
      31              : class FunctionOfTime;
      32              : }  // namespace FunctionsOfTime
      33              : }  // namespace domain
      34              : /// \endcond
      35              : 
      36              : namespace evolution::dg::subcell {
      37              : /// @{
      38              : /*!
      39              :  * \brief Compute and add the 2nd-order flux divergence on a Cartesian mesh to
      40              :  * the cell-centered time derivatives.
      41              :  */
      42            1 : void add_cartesian_flux_divergence(gsl::not_null<DataVector*> dt_var,
      43              :                                    double one_over_delta,
      44              :                                    const DataVector& det_inv_jacobian,
      45              :                                    const DataVector& boundary_correction,
      46              :                                    const Index<1>& subcell_extents,
      47              :                                    size_t dimension);
      48              : 
      49            1 : void add_cartesian_flux_divergence(gsl::not_null<DataVector*> dt_var,
      50              :                                    double one_over_delta,
      51              :                                    const DataVector& det_inv_jacobian,
      52              :                                    const DataVector& boundary_correction,
      53              :                                    const Index<2>& subcell_extents,
      54              :                                    size_t dimension);
      55              : 
      56            1 : void add_cartesian_flux_divergence(gsl::not_null<DataVector*> dt_var,
      57              :                                    double one_over_delta,
      58              :                                    const DataVector& det_inv_jacobian,
      59              :                                    const DataVector& boundary_correction,
      60              :                                    const Index<3>& subcell_extents,
      61              :                                    size_t dimension);
      62              : /// @}
      63              : 
      64              : /*!
      65              :  * \brief Compute and add the 2nd-order flux divergence on a Cartesian mesh to
      66              :  * the cell-centered time derivatives when some of the bases are Cartoon.
      67              :  *
      68              :  * \details Symmetries of your spacetime, used in the cartoon method, allow
      69              :  * the replacement of derivatives perpendicular to the computational domain by
      70              :  * scaled components of that same tensor. Specifically, for a spherically
      71              :  * symmetric system, this allows
      72              :  * \f[
      73              :  * \partial_t u + \partial_x F^x + \partial_y F^y + \partial_z F^z \Rightarrow
      74              :  * \partial_t u + \frac{1}{x^2} \partial_x \left( x^2 F^x \right),
      75              :  * \f]
      76              :  * and for an axially symmetric system,
      77              :  * \f[
      78              :  * \partial_t u + \partial_x F^x + \partial_y F^y + \partial_z F^z \Rightarrow
      79              :  * \partial_t u + \frac{1}{x} \partial_x \left( x F^x \right) + \partial_y F^y.
      80              :  * \f]
      81              :  *
      82              :  * \note This function will assume your basis is Cartoon by `subcell_extents ==
      83              :  * 1` in that dimension (only allowed in the second or third dimension).
      84              :  */
      85            1 : void add_cartoon_cartesian_flux_divergence(
      86              :     gsl::not_null<DataVector*> dt_var, double one_over_delta,
      87              :     const DataVector& det_inv_jacobian, const DataVector& boundary_correction,
      88              :     const Index<3>& subcell_extents, size_t dimension,
      89              :     const tnsr::I<DataVector, 3, Frame::Inertial>& inertial_coords,
      90              :     const ElementMap<3, Frame::Grid>& logical_to_grid_map,
      91              :     const ::domain::CoordinateMapBase<Frame::Grid, Frame::Inertial, 3>&
      92              :         grid_to_inertial_map,
      93              :     double time,
      94              :     const std::unordered_map<
      95              :         std::string,
      96              :         std::unique_ptr<::domain::FunctionsOfTime::FunctionOfTime>>&
      97              :         functions_of_time);
      98              : }  // namespace evolution::dg::subcell