multiphase_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/boundary_conditions.hpp>
#include <meltpooldg/compressible_flow/multiphase_operation.hpp>
#include <meltpooldg/compressible_flow/multiphase_operator.hpp>
#include <meltpooldg/compressible_flow/operation_scratch_data.hpp>
#include <meltpooldg/compressible_flow/state_views.hpp>
#include <meltpooldg/compressible_flow/utils.hpp>
#include <meltpooldg/core/scratch_data.hpp>
#include <meltpooldg/core/simulation_case_base.hpp>
#include <meltpooldg/cut/cut_data.hpp>
#include <meltpooldg/cut/repartition.hpp>
#include <meltpooldg/cut/solution_transfer.hpp>
#include <meltpooldg/cut/util.hpp>
#include <meltpooldg/phase_change/phase_change_data.hpp>
#include <meltpooldg/post_processing/generic_data_out.hpp>
#include <meltpooldg/time_integration/time_iterator.hpp>
 
#include <memory>
#include <variant>
 
namespace MeltPoolDG::Multiphase
{
  template <int dim, typename number>
  class CompressibleMultiphaseOperation
  {
  public:
    using VectorType            = dealii::LinearAlgebra::distributed::Vector<number>;
    using MappingInfoType       = CutUtil::MappingInfoType<dim, number>;
    using MappingInfoVectorType = CutUtil::MappingInfoVectorType<dim, number>;
 
    using ConservedVariablesType = CompressibleFlow::ConservedVariablesType<dim, number>;
 
    using DofStateView = CompressibleFlow::DofStateView<dim, number, const ConservedVariablesType>;
 
    using CompMultiphaseOperatorVariant =
      std::variant<CompressibleMultiphaseOperator<dim, number, true, true>,
                   CompressibleMultiphaseOperator<dim, number, true, false>,
                   CompressibleMultiphaseOperator<dim, number, false, true>,
                   CompressibleMultiphaseOperator<dim, number, false, false>>;
 
    explicit CompressibleMultiphaseOperation(
      const ScratchData<dim, dim, number>               &scratch_data_in,
      const CompressibleFlow::OperationData<number>     &comp_flow_data_in,
      const CompressibleFlow::MaterialPhaseData<number> &material_data_gas_in,
      const CompressibleFlow::MaterialPhaseData<number> &material_data_liquid_in,
      const PhaseChangeData<number>                     &phase_change_data_in,
      const CompressibleFlow::CutSolverData<number>     &cut_data_in,
      const CompressibleFlowPhaseCouplingData<number>   &phase_coupling_data_in,
      const Flow::DarcyDampingData<number>              &darcy_damping_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);
 
    void
    add_external_force(
      std::shared_ptr<CompressibleFlow::ExternalFlowForce<dim, number>> external_force);
 
    number
    compute_time_step_size(bool do_print = false) const;
 
    std::vector<std::complex<number>>
    estimate_jacobian_eigenvalues(const number /*time_step*/) const
    {
      AssertThrow(false,
                  dealii::ExcMessage("Eigenvalue estimation is not implemented for "
                                     "CompressibleMultiphaseOperation."));
      return {};
    }
 
    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);
 
    bool
    repartition(VectorType &level_set_in, const std::function<void()> &distribute_level_set_dofs);
 
    void
    set_boundary_conditions(const std::shared_ptr<SimulationCaseBase<dim, number>> &simulation_case,
                            const std::string                                      &operation_name);
 
    void
    attach_output_vectors(GenericDataOut<dim, number> &data_out) const;
 
    const VectorType &
    get_solution() const;
 
    VectorType &
    get_solution();
 
    VectorType &
    get_solution_in_primitive_variables() const;
 
    const dealii::DoFHandler<dim> &
    get_dof_handler() const;
 
    CompMultiphaseOperatorVariant static create_cut_flow_operator_variant(
      bool                                                           is_viscous_gas,
      bool                                                           is_viscous_liquid,
      CompressibleFlow::MultiphaseOperationScratchData<dim, number> &multiphase_scratch_data,
      const MappingInfoType                                         &mapping_info_surface_in,
      const MappingInfoVectorType                                   &mapping_info_cells_in,
      const MappingInfoVectorType                                   &mapping_info_faces_in)
    {
      if (is_viscous_gas and is_viscous_liquid)
        return CompressibleMultiphaseOperator<dim, number, true, true>(multiphase_scratch_data,
                                                                       mapping_info_surface_in,
                                                                       mapping_info_cells_in,
                                                                       mapping_info_faces_in);
      else if (is_viscous_gas and (not is_viscous_liquid))
        return CompressibleMultiphaseOperator<dim, number, true, false>(multiphase_scratch_data,
                                                                        mapping_info_surface_in,
                                                                        mapping_info_cells_in,
                                                                        mapping_info_faces_in);
      else if ((not is_viscous_gas) and is_viscous_liquid)
        return CompressibleMultiphaseOperator<dim, number, false, true>(multiphase_scratch_data,
                                                                        mapping_info_surface_in,
                                                                        mapping_info_cells_in,
                                                                        mapping_info_faces_in);
      else
        return CompressibleMultiphaseOperator<dim, number, false, false>(multiphase_scratch_data,
                                                                         mapping_info_surface_in,
                                                                         mapping_info_cells_in,
                                                                         mapping_info_faces_in);
    }
 
  private:
    CompressibleFlow::MultiphaseOperationScratchData<dim, number> multiphase_scratch_data;
 
    const TimeIntegration::TimeIterator<number> &time_iterator;
 
    const unsigned int level_set_dof_idx;
 
    const VectorType &level_set;
 
    VectorType rhs;
 
    mutable VectorType solution_primitive_variables;
 
    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;
 
    CompMultiphaseOperatorVariant cmp_operator;
 
    Preconditioner<dim, VectorType, number> preconditioner;
 
    bool preconditioner_update_flag = false;
 
    unsigned int n_steps_performed = 0;
 
    std::unique_ptr<CutUtil::PartitionWeights<dim>> partition_weights;
 
    void
    adapt_to_new_interface_position();
 
    void
    classify_cells() const;
 
    number
    compute_convective_time_step_limit() const;
 
    number
    compute_viscous_time_step_limit(const std::pair<number, number> &min_density) const;
 
    std::pair<number, number>
    compute_minimum_density() const;
 
    void
    compute_intersected_quadrature();
  };
 
  // inlined functions
  template <int dim, typename number>
  const dealii::LinearAlgebra::distributed::Vector<number> &
  CompressibleMultiphaseOperation<dim, number>::get_solution() const
  {
    return multiphase_scratch_data.solution_history.get_current_solution();
  }
 
  template <int dim, typename number>
  dealii::LinearAlgebra::distributed::Vector<number> &
  CompressibleMultiphaseOperation<dim, number>::get_solution()
  {
    return multiphase_scratch_data.solution_history.get_current_solution();
  }
 
  template <int dim, typename number>
  dealii::LinearAlgebra::distributed::Vector<number> &
  CompressibleMultiphaseOperation<dim, number>::get_solution_in_primitive_variables() const
  {
    update_primitive_variables_solution<dim, number, ConservedVariablesType>(
      solution_primitive_variables,
      get_solution(),
      multiphase_scratch_data.scratch_data,
      multiphase_scratch_data.dof_idx,
      multiphase_scratch_data.quad_idx,
      &multiphase_scratch_data.material_liquid,
      &multiphase_scratch_data.material_gas);
    return solution_primitive_variables;
  }
 
  template <int dim, typename number>
  const dealii::DoFHandler<dim> &
  CompressibleMultiphaseOperation<dim, number>::get_dof_handler() const
  {
    return multiphase_scratch_data.scratch_data.get_dof_handler(multiphase_scratch_data.dof_idx);
  }
 
} // namespace MeltPoolDG::Multiphase