operation_data.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/parameter_handler.h>
 
#include <meltpooldg/core/finite_element_data.hpp>
#include <meltpooldg/cut/cut_data.hpp>
#include <meltpooldg/time_integration/time_integrator_data.hpp>
#include <meltpooldg/time_integration/time_integrator_util.hpp>
#include <meltpooldg/utilities/better_enum.hpp>
#include <meltpooldg/utilities/limiters.hpp>
#include <meltpooldg/utilities/limiters.templates.hpp>
 
#include <string>
#include <vector>
 
namespace MeltPoolDG::CompressibleFlow
{
  BETTER_ENUM(NumericalFluxType,
              char,
              lax_friedrichs_modified,
              lax_friedrichs_exact,
              harten_lax_vanleer)
 
  BETTER_ENUM(LinearizedConvectiveFluxJumpType, char, analytic, lambda_fd, complete_fd);
 
  BETTER_ENUM(JacobianType, char, exact, finite_difference);
 
  BETTER_ENUM(OutputType, char, conserved_variables, primitive_variables, material_quantities);
 
  template <typename number>
  struct OperationData
  {
    FiniteElementData fe;
 
    TimeIntegration::TimeIntegratorData<number> time_integrator;
 
    NumericalFluxType numerical_flux_type = NumericalFluxType::lax_friedrichs_modified;
 
    LinearizedConvectiveFluxJumpType linearization_jump_convective_flux =
      LinearizedConvectiveFluxJumpType::complete_fd;
 
    JacobianType jacobian_type = JacobianType::exact;
 
    number courant_number = 0.15;
 
    number viscous_courant_number = 1.0;
 
    bool do_cfl_time_stepping = false;
 
    number gravity_constant = 0.0;
 
    std::string domain_representation_type = "fitted";
 
    int verbosity_level = -1;
 
    Utilities::LimiterData<number> limiter_data;
 
    std::vector<OutputType> output_variables = {OutputType::conserved_variables};
 
    void
    add_parameters(dealii::ParameterHandler &prm)
    {
      prm.enter_subsection("compressible navier stokes");
      {
        fe.add_parameters(prm);
        time_integrator.add_parameters(prm);
        prm.add_parameter(
          "linearization jump convective flux",
          linearization_jump_convective_flux,
          "Calculation method of the linearized jump operator in the convective "
          "numerical flux (required for implicit time stepping). The options are \"analytic\","
          " \"complete_fd\" and \"lambda_fd\".");
        prm.add_parameter("numerical flux type",
                          numerical_flux_type,
                          "Type of the numerical flux.");
        prm.add_parameter("courant number",
                          courant_number,
                          "Courant number for convective time-step limit.");
        prm.add_parameter("viscous courant number",
                          viscous_courant_number,
                          "Characteristic Courant-like number for viscous time-step limit.");
 
        prm.add_parameter("jacobian type",
                          jacobian_type,
                          "Type of the jacobian. Choose between 'exact' and 'finite_difference'.");
        prm.add_parameter(
          "use cfl criteria",
          do_cfl_time_stepping,
          "If set to true, the CFL time step size criteria is used to determine the time step"
          " size in each iteration.");
        prm.add_parameter("gravity constant", gravity_constant, "Gravity constant.");
        prm.add_parameter("domain representation type",
                          domain_representation_type,
                          "Domain representation type. Choose between 'fitted' and 'cut'.",
                          dealii::Patterns::Selection("fitted|cut"));
        prm.add_parameter("verbosity level", verbosity_level, "Verbosity level for output.");
        limiter_data.add_parameters(prm);
      }
      prm.leave_subsection();
 
      prm.enter_subsection("output");
      {
        prm.enter_subsection("paraview");
        {
          prm.add_parameter("compressible output types",
                            output_variables,
                            "Type of the variables added to the output.");
        }
        prm.leave_subsection();
      }
      prm.leave_subsection();
    }
 
    void
    post(const FiniteElementData &base_fe_data, const unsigned int base_verbosity_level)
    {
      fe.post(base_fe_data);
      AssertThrow(fe.type == FiniteElementType::FE_DGQ,
                  dealii::ExcMessage(
                    "The compressible flow solver only supports elements of type 'FE_DGQ'."));
 
      // set default time integration scheme for cut
      if (domain_representation_type == "cut")
        {
          if (time_integrator.integrator_type ==
              TimeIntegration::TimeIntegratorSchemes::not_initialized)
            time_integrator.integrator_type =
              TimeIntegration::TimeIntegratorSchemes::explicit_euler;
          AssertThrow(
            time_integrator.integrator_type ==
              TimeIntegration::TimeIntegratorSchemes::explicit_euler,
            dealii::ExcMessage(
              "The cut compressible flow solver only supports explicit Euler time integration."));
        }
 
      // Synchronize verbosity with base verbosity if not set explicitly.
      if (verbosity_level < 0)
        verbosity_level = base_verbosity_level;
    }
  };
 
  template <typename number>
  struct CutSolverData
  {
    std::string unfitted_flow_boundary_condition = "no_slip_wall";
 
    CutStabilizationData<number> stabilization;
 
    void
    add_parameters(dealii::ParameterHandler &prm)
    {
      prm.enter_subsection("cut");
      {
        prm.add_parameter("unfitted flow boundary condition",
                          unfitted_flow_boundary_condition,
                          "Flow boundary condition type at the unfitted boundary. "
                          "Choose between 'no_slip_wall' and 'inflow'.");
        stabilization.add_parameters(prm);
      }
      prm.leave_subsection();
    }
  };
} // namespace MeltPoolDG::CompressibleFlow