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 <optional>
       9              : #include <pup.h>
      10              : #include <string>
      11              : 
      12              : #include "DataStructures/Tensor/TypeAliases.hpp"
      13              : #include "Domain/BoundaryConditions/BoundaryCondition.hpp"
      14              : #include "Evolution/BoundaryConditions/Type.hpp"
      15              : #include "Evolution/Systems/NewtonianEuler/BoundaryConditions/BoundaryCondition.hpp"
      16              : #include "Evolution/Systems/NewtonianEuler/Tags.hpp"
      17              : #include "Options/String.hpp"
      18              : #include "PointwiseFunctions/Hydro/Tags.hpp"
      19              : #include "Utilities/TMPL.hpp"
      20              : 
      21              : /// \cond
      22              : class DataVector;
      23              : namespace gsl {
      24              : template <class T>
      25              : class not_null;
      26              : }  // namespace gsl
      27              : /// \endcond
      28              : 
      29              : namespace NewtonianEuler::BoundaryConditions {
      30              : /*!
      31              :  * \brief Reflecting boundary conditions for Newtonian hydrodynamics.
      32              :  *
      33              :  * Ghost (exterior) data 'mirrors' interior volume data with respect to the
      34              :  * boundary interface. i.e. reverses the normal component of velocity while
      35              :  * using same values for other scalar quantities.
      36              :  *
      37              :  * In the frame instantaneously moving with the same velocity as face mesh, the
      38              :  * reflection condition reads
      39              :  *
      40              :  * \f{align*}
      41              :  * \vec{u}_\text{ghost} = \vec{u}_\text{int} - 2 (\vec{u}_\text{int} \cdot
      42              :  * \hat{n}) \hat{n}
      43              :  * \f}
      44              :  *
      45              :  * where \f$\vec{u}\f$ is the fluid velocity in the moving frame, "int" stands
      46              :  * for interior, and \f$\hat{n}\f$ is the outward normal vector on the boundary
      47              :  * interface.
      48              :  *
      49              :  * Substituting \f$\vec{u} = \vec{v} - \vec{v}_m\f$, we get
      50              :  *
      51              :  * \f{align*}
      52              :  * v_\text{ghost}^i &= v_\text{int}^i - 2[(v_\text{int}^j-v_m^j)n_j]n^i
      53              :  * \f}
      54              :  *
      55              :  * where \f$v\f$ is the fluid velocity and \f$v_m\f$ is face mesh velocity.
      56              :  *
      57              :  */
      58              : template <size_t Dim>
      59            1 : class Reflection final : public BoundaryCondition<Dim> {
      60              :  public:
      61            0 :   using options = tmpl::list<>;
      62            0 :   static constexpr Options::String help{
      63              :       "Reflecting boundary conditions for Newtonian hydrodynamics."};
      64              : 
      65            0 :   Reflection() = default;
      66            0 :   Reflection(Reflection&&) = default;
      67            0 :   Reflection& operator=(Reflection&&) = default;
      68            0 :   Reflection(const Reflection&) = default;
      69            0 :   Reflection& operator=(const Reflection&) = default;
      70            0 :   ~Reflection() override = default;
      71              : 
      72            0 :   explicit Reflection(CkMigrateMessage* msg);
      73              : 
      74            0 :   WRAPPED_PUPable_decl_base_template(
      75              :       domain::BoundaryConditions::BoundaryCondition, Reflection);
      76              : 
      77            0 :   auto get_clone() const -> std::unique_ptr<
      78              :       domain::BoundaryConditions::BoundaryCondition> override;
      79              : 
      80            0 :   static constexpr evolution::BoundaryConditions::Type bc_type =
      81              :       evolution::BoundaryConditions::Type::Ghost;
      82              : 
      83            0 :   void pup(PUP::er& p) override;
      84              : 
      85            0 :   using dg_interior_evolved_variables_tags = tmpl::list<>;
      86            0 :   using dg_interior_temporary_tags = tmpl::list<>;
      87            0 :   using dg_interior_primitive_variables_tags =
      88              :       tmpl::list<hydro::Tags::RestMassDensity<DataVector>,
      89              :                  hydro::Tags::SpatialVelocity<DataVector, Dim>,
      90              :                  hydro::Tags::SpecificInternalEnergy<DataVector>,
      91              :                  hydro::Tags::Pressure<DataVector>>;
      92            0 :   using dg_gridless_tags = tmpl::list<>;
      93              : 
      94            0 :   std::optional<std::string> dg_ghost(
      95              :       gsl::not_null<Scalar<DataVector>*> mass_density,
      96              :       gsl::not_null<tnsr::I<DataVector, Dim, Frame::Inertial>*>
      97              :           momentum_density,
      98              :       gsl::not_null<Scalar<DataVector>*> energy_density,
      99              : 
     100              :       gsl::not_null<tnsr::I<DataVector, Dim, Frame::Inertial>*>
     101              :           flux_mass_density,
     102              :       gsl::not_null<tnsr::IJ<DataVector, Dim, Frame::Inertial>*>
     103              :           flux_momentum_density,
     104              :       gsl::not_null<tnsr::I<DataVector, Dim, Frame::Inertial>*>
     105              :           flux_energy_density,
     106              : 
     107              :       gsl::not_null<tnsr::I<DataVector, Dim, Frame::Inertial>*> velocity,
     108              :       gsl::not_null<Scalar<DataVector>*> specific_internal_energy,
     109              : 
     110              :       const std::optional<tnsr::I<DataVector, Dim, Frame::Inertial>>&
     111              :           face_mesh_velocity,
     112              :       const tnsr::i<DataVector, Dim, Frame::Inertial>&
     113              :           outward_directed_normal_covector,
     114              : 
     115              :       const Scalar<DataVector>& interior_mass_desity,
     116              :       const tnsr::I<DataVector, Dim, Frame::Inertial>& interior_velocity,
     117              :       const Scalar<DataVector>& interior_specific_internal_energy,
     118              :       const Scalar<DataVector>& interior_pressure) const;
     119              : };
     120              : 
     121              : }  // namespace NewtonianEuler::BoundaryConditions