dg_operation.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/function.h>
 
#include <deal.II/lac/la_parallel_vector.h>
 
#include "meltpooldg/time_integration/time_integrator_base.hpp"
#include <meltpooldg/compressible_flow/dg_operator_explicit.hpp>
#include <meltpooldg/compressible_flow/dg_operator_implicit.hpp>
#include <meltpooldg/compressible_flow/dg_operator_implicit_explicit.hpp>
#include <meltpooldg/compressible_flow/operation_data.hpp>
#include <meltpooldg/compressible_flow/operation_scratch_data.hpp>
#include <meltpooldg/compressible_flow/output_post_processor.hpp>
#include <meltpooldg/compressible_flow/utils.hpp>
#include <meltpooldg/core/scratch_data.hpp>
#include <meltpooldg/post_processing/generic_data_out.hpp>
#include <meltpooldg/time_integration/bdf_time_integration.hpp>
#include <meltpooldg/time_integration/explicit_low_storage_runge_kutta_integrator.hpp>
#include <meltpooldg/time_integration/implicit_explicit_integrator.hpp>
#include <meltpooldg/time_integration/solution_history.hpp>
 
#include <memory>
#include <string>
 
namespace MeltPoolDG::CompressibleFlow
{
  template <int dim, typename number, int n_species = 1>
  class DGOperation
  {
  public:
    using VectorType = dealii::LinearAlgebra::distributed::Vector<number>;
 
    explicit DGOperation(const ScratchData<dim, dim, number> &scratch_data,
                         const OperationData<number>         &flow_data,
                         const MaterialPhaseData<number>     &material_data_in,
                         unsigned int                         flow_dof_idx  = 0,
                         unsigned int                         flow_quad_idx = 0);
 
    void
    reinit();
 
    void
    solve(const number current_time, const number time_step);
 
    void
    distribute_dofs(dealii::DoFHandler<dim> &dof_handler) const;
 
    void
    set_boundary_conditions(const std::shared_ptr<SimulationCaseBase<dim, number>> &simulation_case,
                            const std::string                                      &operation_name);
 
    void
    set_body_force(std::unique_ptr<dealii::Function<dim>> body_force_in);
 
    void
    add_external_force(
      std::shared_ptr<ExternalFlowForce<dim, number, n_species>>         external_force_residuum,
      std::shared_ptr<ExternalFlowForceJacobian<dim, number, n_species>> external_force_jacobian);
 
    number
    compute_time_step_size(bool do_print = false) const;
 
    void
    set_initial_condition(const dealii::Function<dim> &function);
 
    void
    attach_output_vectors(GenericDataOut<dim, number> &data_out) const;
 
    const VectorType &
    get_solution() const;
 
    VectorType &
    get_solution();
 
    const dealii::DoFHandler<dim> &
    get_dof_handler() const;
 
  private:
    OperationScratchData<dim, number> flow_scratch_data;
 
    std::unique_ptr<TimeIntegration::TimeIntegratorBase<number>> time_integrator;
 
    std::variant<DGOperatorExplicit<dim, number, n_species>,
                 DGOperatorImplicit<dim, number>,
                 DGOperatorImplicitExplicit<dim, number>>
      flow_operator;
 
    OutputManager<dim, number> output_manager;
 
    number
    compute_convective_time_step_limit() const;
 
    number
    compute_minimum_density() const;
 
    static std::variant<DGOperatorExplicit<dim, number, n_species>,
                        DGOperatorImplicit<dim, number>,
                        DGOperatorImplicitExplicit<dim, number>>
    setup_operator(OperationScratchData<dim, number> &flow_scratch_data);
 
    void
    setup_time_integrator();
  };
 
 
  template <int dim, typename number, int n_species>
  const dealii::LinearAlgebra::distributed::Vector<number> &
  DGOperation<dim, number, n_species>::get_solution() const
  {
    return flow_scratch_data.solution_history.get_current_solution();
  }
 
  template <int dim, typename number, int n_species>
  dealii::LinearAlgebra::distributed::Vector<number> &
  DGOperation<dim, number, n_species>::get_solution()
  {
    return flow_scratch_data.solution_history.get_current_solution();
  }
 
  template <int dim, typename number, int n_species>
  const dealii::DoFHandler<dim> &
  DGOperation<dim, number, n_species>::get_dof_handler() const
  {
    return flow_scratch_data.scratch_data.get_dof_handler(flow_scratch_data.dof_idx);
  }
 
} // namespace MeltPoolDG::CompressibleFlow