cutdg_operation.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <deal.II/base/function.h>
 
#include <deal.II/fe/fe_system.h>
 
#include <deal.II/non_matching/mesh_classifier.h>
 
#include <meltpooldg/compressible_flow/cutdg_operator.hpp>
#include <meltpooldg/compressible_flow/data_types.hpp>
#include <meltpooldg/compressible_flow/material.hpp>
#include <meltpooldg/compressible_flow/operation_data.hpp>
#include <meltpooldg/compressible_flow/output_post_processor.hpp>
#include <meltpooldg/compressible_flow/utils.hpp>
#include <meltpooldg/core/scratch_data.hpp>
#include <meltpooldg/cut/solution_transfer.hpp>
#include <meltpooldg/cut/util.hpp>
#include <meltpooldg/post_processing/generic_data_out.hpp>
#include <meltpooldg/time_integration/time_iterator.hpp>
#include <meltpooldg/utilities/vector_tools.templates.hpp>
 
#include <memory>
#include <variant>
 
namespace MeltPoolDG::CompressibleFlow
{
  template <int dim, typename number>
  class CutDGOperation
  {
  public:
    using VectorType            = dealii::LinearAlgebra::distributed::Vector<number>;
    using MappingInfoType       = CutUtil::MappingInfoType<dim, number>;
    using MappingInfoVectorType = CutUtil::MappingInfoVectorType<dim, number>;
 
    using ConservedVariables = ConservedVariablesType<dim, number>;
 
    using CutFlowOperatorVariant =
      std::variant<CutDGOperator<dim, number, true>, CutDGOperator<dim, number, false>>;
    explicit CutDGOperation(
      const ScratchData<dim, dim, number>         &scratch_data_in,
      const OperationData<number>                 &comp_flow_data_in,
      const MaterialPhaseData<number>             &material_data_in,
      const CutSolverData<number>                 &cut_data_in,
      const TimeIntegration::TimeIterator<number> &time_iterator_in,
      const std::function<void()>                 &setup_dof_system_in,
      const VectorType                            &level_set_in,
      unsigned int comp_flow_dof_idx_in  = dealii::numbers::invalid_unsigned_int,
      unsigned int level_set_dof_idx_in  = dealii::numbers::invalid_unsigned_int,
      unsigned int comp_flow_quad_idx_in = dealii::numbers::invalid_unsigned_int);
 
    void
    reinit();
 
    void
    set_body_force(std::unique_ptr<dealii::Function<dim>> body_force_in);
 
    number
    compute_time_step_size(bool do_print = false) const;
 
    void
    distribute_dofs(dealii::DoFHandler<dim> &dof_handler) const;
 
    void
    solve(number current_time, number time_step);
 
    void
    set_initial_condition(const dealii::Function<dim> &function);
 
    void
    set_inflow_field_unfitted_boundary(std::shared_ptr<dealii::Function<dim>> &inflow_function);
 
    void
    set_unfitted_object_velocity(std::shared_ptr<dealii::Function<dim>> &velocity_function);
 
    void
    set_boundary_conditions(const std::shared_ptr<SimulationCaseBase<dim, number>> &simulation_case,
                            const std::string                                      &operation_name);
 
    std::vector<std::complex<number>>
    estimate_jacobian_eigenvalues(const number /*time_step*/) const
    {
      AssertThrow(false,
                  dealii::ExcMessage("Eigenvalue estimation is not implemented for "
                                     "CutDGOperation."));
      return {};
    }
 
    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;
 
    CutFlowOperatorVariant static create_cut_flow_operator_variant(
      bool                               is_viscous,
      OperationScratchData<dim, number> &flow_scratch_data,
      const MappingInfoType             &mapping_info_surface_in,
      const MappingInfoVectorType       &mapping_info_cells_in,
      const MappingInfoVectorType       &mapping_info_faces_in)
    {
      if (is_viscous)
        return CutDGOperator<dim, number, true>(flow_scratch_data,
                                                mapping_info_surface_in,
                                                mapping_info_cells_in,
                                                mapping_info_faces_in);
      else
        return CutDGOperator<dim, number, false>(flow_scratch_data,
                                                 mapping_info_surface_in,
                                                 mapping_info_cells_in,
                                                 mapping_info_faces_in);
    }
 
  private:
    OperationScratchData<dim, number> flow_scratch_data;
 
    const TimeIntegration::TimeIterator<number> &time_iterator;
 
    const unsigned int level_set_dof_idx;
 
    const VectorType &level_set;
 
    VectorType rhs;
 
    std::shared_ptr<dealii::NonMatching::MeshClassifier<dim>> mesh_classifier;
 
    std::shared_ptr<dealii::NonMatching::MeshClassifier<dim>> mesh_classifier_old;
 
    CutUtil::SolutionTransferOperator<dim, number> cut_solution_transfer;
 
    std::function<void()> setup_dof_system;
 
    std::function<void(VectorType &)> reinit_vector;
 
    dealii::FESystem<dim> fe_point_temp;
 
    const unsigned int n_dofs_per_cell;
 
    MappingInfoType mapping_info_surface;
 
    MappingInfoVectorType mapping_info_cells;
 
    MappingInfoVectorType mapping_info_faces;
 
    CutFlowOperatorVariant cut_flow_operator;
 
    OutputManager<dim, number> output_manager;
 
    void
    adapt_to_new_interface_position();
 
    void
    classify_cells() const;
 
    number
    compute_convective_time_step_limit() const;
 
    number
    compute_minimum_density() const;
 
    void
    compute_intersected_quadrature();
  };
 
  template <int dim, typename number>
  const dealii::LinearAlgebra::distributed::Vector<number> &
  CutDGOperation<dim, number>::get_solution() const
  {
    return flow_scratch_data.solution_history.get_current_solution();
  }
 
  template <int dim, typename number>
  dealii::LinearAlgebra::distributed::Vector<number> &
  CutDGOperation<dim, number>::get_solution()
  {
    return flow_scratch_data.solution_history.get_current_solution();
  }
 
  template <int dim, typename number>
  const dealii::DoFHandler<dim> &
  CutDGOperation<dim, number>::get_dof_handler() const
  {
    return flow_scratch_data.scratch_data.get_dof_handler(flow_scratch_data.dof_idx);
  }
 
} // namespace MeltPoolDG::CompressibleFlow