boundary_conditions.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/function.h>
#include <deal.II/base/point.h>
#include <deal.II/base/tensor.h>
#include <deal.II/base/vectorization.h>
 
#include <meltpooldg/compressible_flow/data_types.hpp>
#include <meltpooldg/compressible_flow/material.hpp>
#include <meltpooldg/compressible_flow/material_data.hpp>
#include <meltpooldg/compressible_flow/operation_data.hpp>
#include <meltpooldg/compressible_flow/state_views.hpp>
#include <meltpooldg/core/simulation_case_base.hpp>
#include <meltpooldg/utilities/better_enum.hpp>
#include <meltpooldg/utilities/vector_tools.hpp>
 
#include <map>
#include <memory>
#include <set>
 
namespace MeltPoolDG::CompressibleFlow
{
  BETTER_ENUM(BoundaryConditionType,
              char,
              combined_inflow_no_slip_wall,
              inflow,
              slip_wall,
              no_slip_wall,
              subsonic_outflow_fixed_energy,
              subsonic_outflow_fixed_pressure);
 
  template <int dim>
  struct CombinedInflowNoSlipWallValueInterpretation
  {
    enum
    {
      inside_flow = 0,
      density,
      velocity,
      energy = dim + 2,
      mass_fractions
    };
  };
 
  template <int dim>
  struct InflowValueInterpretation
  {
    enum
    {
      density = 0,
      velocity,
      energy = dim + 1,
      mass_fractions
    };
  };
 
 
  template <int dim, typename number>
  class BoundaryConditions
  {
  public:
    using ConservedVariables         = ConservedVariablesType<dim, number>;
    using ConservedVariablesGradient = ConservedVariablesGradientType<dim, number>;
    using BoundaryType               = BoundaryConditionType;
 
    using VectorizedArrayType = dealii::VectorizedArray<number>;
 
    inline static const std::map<BoundaryType, std::string> boundary_type_to_string_map = {
      {BoundaryType::inflow, "inflow"},
      {BoundaryType::subsonic_outflow_fixed_pressure, "outflow_fixed_pressure"},
      {BoundaryType::subsonic_outflow_fixed_energy, "outflow_fixed_energy"},
      {BoundaryType::slip_wall, "slip_wall"},
      {BoundaryType::no_slip_wall, "no_slip_wall"},
      {BoundaryType::combined_inflow_no_slip_wall, "combined_inflow_no_slip_wall"},
    };
 
    void
    update_boundary_conditions(number time);
 
    void
    set_boundary_conditions(const std::shared_ptr<SimulationCaseBase<dim, number>> &simulation_case,
                            const std::string                                      &operation_name)
    {
      set_boundary_condition(BoundaryType::inflow,
                             simulation_case->get_boundary_condition("inflow", operation_name));
 
      set_boundary_condition(BoundaryType::subsonic_outflow_fixed_pressure,
                             simulation_case->get_boundary_condition("outflow_fixed_pressure",
                                                                     operation_name));
 
      set_boundary_condition(BoundaryType::subsonic_outflow_fixed_energy,
                             simulation_case->get_boundary_condition("outflow_fixed_energy",
                                                                     operation_name));
 
      set_boundary_condition(BoundaryType::slip_wall,
                             simulation_case->get_boundary_condition("slip_wall", operation_name));
 
      set_boundary_condition(BoundaryType::no_slip_wall,
                             simulation_case->get_boundary_condition("no_slip_wall",
                                                                     operation_name));
 
      set_boundary_condition(BoundaryType::combined_inflow_no_slip_wall,
                             simulation_case->get_boundary_condition("combined_inflow_no_slip_wall",
                                                                     operation_name));
    }
 
    void
    set_boundary_condition(
      BoundaryType boundary_condition,
      std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>>
        boundary_condition_function = {});
 
    BoundaryType
    get_boundary_type(const dealii::types::boundary_id boundary_id) const
    {
      if (inflow_boundaries.contains(boundary_id))
        return BoundaryType::inflow;
      if (slip_wall_boundaries.contains(boundary_id))
        return BoundaryType::slip_wall;
      if (no_slip_adiabatic_wall_boundaries.contains(boundary_id))
        return BoundaryType::no_slip_wall;
      if (subsonic_outflow_fixed_energy.contains(boundary_id))
        return BoundaryType::subsonic_outflow_fixed_energy;
      if (subsonic_outflow_fixed_pressure.contains(boundary_id))
        return BoundaryType::subsonic_outflow_fixed_pressure;
      if (combined_inflow_no_slip_wall_boundaries.contains(boundary_id))
        return BoundaryType::combined_inflow_no_slip_wall;
      AssertThrow(false,
                  dealii::ExcMessage(
                    "There is no compressible flow boundary set at the boundary with boundary id " +
                    std::to_string(boundary_id) + "!"));
    }
 
    dealii::VectorizedArray<number>
    get_boundary_value(dealii::types::boundary_id boundary_id,
                       BoundaryType               boundary_condition,
                       const dealii::Point<dim, dealii::VectorizedArray<number>> &location,
                       unsigned                                                   component) const;
 
    std::tuple<ConservedVariables, ConservedVariablesGradient>
    get_boundary_face_value_and_gradient(
      const dealii::Point<dim, dealii::VectorizedArray<number>>     &q_point,
      const dealii::Tensor<1, dim, dealii::VectorizedArray<number>> &normal,
      dealii::types::boundary_id                                     boundary_id,
      const ConservedVariables                                      &w_m,
      const ConservedVariablesGradient                              &grad_w_m,
      const Material<dim, number>                                   &material,
      bool                                                           is_gas_phase = true) const;
 
    template <typename DofReadView, typename DofWriteView>
    void
    set_conserved_variables_boundary_value_and_gradient(
      const dealii::Point<dim, dealii::VectorizedArray<number>>     &q_point,
      const dealii::Tensor<1, dim, dealii::VectorizedArray<number>> &normal,
      dealii::types::boundary_id                                     boundary_id,
      const DofReadView                                             &w_m,
      const DofWriteView                                            &w_p) const;
 
    template <int n_species, typename DofReadView, typename DofWriteView>
    void
    set_partial_density_boundary_value_and_gradient(
      const dealii::Point<dim, dealii::VectorizedArray<number>> &q_point,
      dealii::types::boundary_id                                 boundary_id,
      const DofReadView                                         &w_m,
      const DofWriteView                                        &w_p) const;
 
    std::tuple<ConservedVariables,
               ConservedVariablesGradient,
               ConservedVariables,
               ConservedVariablesGradient>
    get_jacobian_boundary_face_value_and_gradient(
      const dealii::Point<dim, dealii::VectorizedArray<number>>     &q_point,
      const dealii::Tensor<1, dim, dealii::VectorizedArray<number>> &normal,
      dealii::types::boundary_id                                     boundary_id,
      const ConservedVariables                                      &w_m,
      const ConservedVariables                                      &delta_w_m,
      const ConservedVariablesGradient                              &grad_w_m,
      const ConservedVariablesGradient                              &grad_delta_w_m,
      number                                                         gamma) const;
 
  private:
    std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>> inflow_boundaries;
    std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>>
      subsonic_outflow_fixed_pressure;
    std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>>
      subsonic_outflow_fixed_energy;
    std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>>
      combined_inflow_no_slip_wall_boundaries;
 
    std::set<dealii::types::boundary_id> slip_wall_boundaries;
    std::set<dealii::types::boundary_id> no_slip_adiabatic_wall_boundaries;
 
    template <typename DofReadView, typename DofWriteView>
    void
    apply_slip_wall_boundary(
      DofReadView                                                    w_m,
      DofWriteView                                                   w_p,
      const dealii::Tensor<1, dim, dealii::VectorizedArray<number>> &normal) const;
 
    template <typename DofReadView, typename DofWriteView>
    void
    apply_no_slip_wall_boundary(DofReadView w_m, DofWriteView w_p) const;
 
    template <typename DofReadView,
              typename DofWriteView,
              typename DirichletValueInterpretation = InflowValueInterpretation<dim>>
    void
    apply_inflow_boundary(const dealii::types::boundary_id                           boundary_id,
                          const dealii::Point<dim, dealii::VectorizedArray<number>> &q_point,
                          DofReadView                                                w_m,
                          DofWriteView                                               w_p,
                          const BoundaryType bc_value_type = BoundaryType::inflow) const;
 
    template <typename DofReadView, typename DofWriteView>
    void
    apply_subsonic_outflow_with_fixed_pressure_boundary(
      const dealii::types::boundary_id                           boundary_id,
      const dealii::Point<dim, dealii::VectorizedArray<number>> &q_point,
      DofReadView                                                w_m,
      DofWriteView                                               w_p) const;
 
    template <typename DofReadView, typename DofWriteView>
    void
    apply_subsonic_outflow_with_fixed_energy_boundary(
      const dealii::types::boundary_id                           boundary_id,
      const dealii::Point<dim, dealii::VectorizedArray<number>> &q_point,
      DofReadView                                                w_m,
      DofWriteView                                               w_p) const;
 
    template <typename DofReadView, typename DofWriteView>
    void
    apply_combined_inflow_no_slip_wall_boundary(
      const dealii::types::boundary_id                           boundary_id,
      const dealii::Point<dim, dealii::VectorizedArray<number>> &q_point,
      DofReadView                                                w_m,
      DofWriteView                                               w_p) const;
  };
} // namespace MeltPoolDG::CompressibleFlow