adaflo_wrapper.hpp

Go to the documentation of this file.

#pragma once
 
#ifdef MPDG_ENABLE_ADAFLO
 
#  include <deal.II/base/function.h>
#  include <deal.II/base/quadrature.h>
#  include <deal.II/base/tensor.h>
#  include <deal.II/base/timer.h>
#  include <deal.II/base/vectorization.h>
 
#  include <deal.II/dofs/dof_handler.h>
 
#  include <deal.II/grid/tria.h>
 
#  include <deal.II/lac/affine_constraints.h>
#  include <deal.II/lac/generic_linear_algebra.h>
#  include <deal.II/lac/la_parallel_vector.h>
 
#  include <meltpooldg/core/base_data.hpp>
#  include <meltpooldg/core/material.hpp>
#  include <meltpooldg/core/scratch_data.hpp>
#  include <meltpooldg/core/simulation_case_base.hpp>
#  include <meltpooldg/flow/adaflo_wrapper_parameters.hpp>
#  include <meltpooldg/flow/incompressible_flow_operation_base.hpp>
#  include <meltpooldg/phase_change/evaporation_data.hpp>
#  include <meltpooldg/post_processing/generic_data_out.hpp>
#  include <meltpooldg/time_integration/time_iterator.hpp>
#  include <meltpooldg/time_integration/time_stepping_data.hpp>
 
#  include <adaflo/navier_stokes.h>
#  include <adaflo/parameters.h>
 
#  include <functional>
#  include <memory>
#  include <string>
#  include <vector>
 
namespace MeltPoolDG::Flow
{
  template <int dim, typename number>
  class AdafloWrapper : public IncompressibleFlowOperationBase<dim, number>
  {
  public:
    using VectorType = dealii::LinearAlgebra::distributed::Vector<number>;
 
    AdafloWrapper(ScratchData<dim, dim, number>                               &scratch_data,
                  const std::shared_ptr<const SimulationCaseBase<dim, number>> simulation_case,
                  const AdafloWrapperParameters<number>       &adaflo_wrapper_params,
                  const TimeIntegration::TimeIterator<number> &time_iterator,
                  const bool                                   do_evaporative_mass_flux);
 
    void
    set_initial_condition(const dealii::Function<dim> &initial_field_function_velocity) override;
 
    // TODO: Give this function a reasonable name
    void
    reinit_1();
 
    // TODO: Give this function a reasonable name
    void
    reinit_2();
 
    // TODO: Give this function a reasonable name
    void
    reinit_3();
 
    void
    init_time_advance() override;
 
    void
    solve() override;
 
    void
    set_face_average_density_augmented_taylor_hood(const Material<number> &material,
                                                   const VectorType       &ls_as_heaviside,
                                                   const unsigned int      ls_dof_idx,
                                                   const VectorType       *temperature  = nullptr,
                                                   unsigned int            temp_dof_idx = -1);
 
    const dealii::LinearAlgebra::distributed::Vector<number> &
    get_velocity() const override;
 
    dealii::LinearAlgebra::distributed::Vector<number> &
    get_velocity() override;
 
    const dealii::LinearAlgebra::distributed::Vector<number> &
    get_velocity_old() const override;
 
    const dealii::LinearAlgebra::distributed::Vector<number> &
    get_velocity_old_old() const;
 
    const dealii::DoFHandler<dim> &
    get_dof_handler_velocity() const override;
 
    const unsigned int &
    get_dof_handler_idx_velocity() const override;
 
    const unsigned int &
    get_dof_handler_idx_hanging_nodes_velocity() const override;
 
    const unsigned int &
    get_quad_idx_velocity() const override;
 
    const unsigned int &
    get_quad_idx_pressure() const override;
 
    const dealii::AffineConstraints<number> &
    get_constraints_velocity() const override;
 
    dealii::AffineConstraints<number> &
    get_constraints_velocity() override;
 
    const dealii::AffineConstraints<number> &
    get_hanging_node_constraints_velocity() const override;
 
    const dealii::LinearAlgebra::distributed::Vector<number> &
    get_pressure() const override;
 
    dealii::LinearAlgebra::distributed::Vector<number> &
    get_pressure() override;
 
    const dealii::LinearAlgebra::distributed::Vector<number> &
    get_pressure_old() const;
 
    const dealii::LinearAlgebra::distributed::Vector<number> &
    get_pressure_old_old() const;
 
    const dealii::DoFHandler<dim> &
    get_dof_handler_pressure() const override;
 
    const unsigned int &
    get_dof_handler_idx_pressure() const override;
 
    const dealii::AffineConstraints<number> &
    get_constraints_pressure() const override;
 
    dealii::AffineConstraints<number> &
    get_constraints_pressure() override;
 
    const dealii::AffineConstraints<number> &
    get_hanging_node_constraints_pressure() const override;
 
    void
    set_force_rhs(const dealii::LinearAlgebra::distributed::Vector<number> &vec) override;
 
    void
    set_mass_balance_rhs(const dealii::LinearAlgebra::distributed::Vector<number> &vec) override;
 
    void
    set_user_defined_material(std::function<dealii::Tensor<2, dim, dealii::VectorizedArray<number>>(
                                const dealii::Tensor<2, dim, dealii::VectorizedArray<number>> &,
                                const unsigned int,
                                const unsigned int,
                                const bool)> my_user_defined_material) override;
 
    dealii::VectorizedArray<number> &
    get_density(const unsigned int cell, const unsigned int q) override;
 
    const dealii::VectorizedArray<number> &
    get_density(const unsigned int cell, const unsigned int q) const override;
 
    dealii::VectorizedArray<number> &
    get_viscosity(const unsigned int cell, const unsigned int q) override;
 
    const dealii::VectorizedArray<number> &
    get_viscosity(const unsigned int cell, const unsigned int q) const override;
 
    dealii::VectorizedArray<number> &
    get_damping(const unsigned int cell, const unsigned int q) override;
 
    const dealii::VectorizedArray<number> &
    get_damping(const unsigned int cell, const unsigned int q) const override;
 
    void
    attach_vectors_u(
      std::vector<dealii::LinearAlgebra::distributed::Vector<number> *> &vectors) override;
 
    void
    attach_vectors_p(
      std::vector<dealii::LinearAlgebra::distributed::Vector<number> *> &vectors) override;
 
    void
    distribute_constraints() override;
 
    void
    attach_output_vectors(GenericDataOut<dim, number> &data_out) const override;
 
    void
    attach_output_vectors_failed_step(GenericDataOut<dim, number> &data_out) const override;
 
    void
    set_face_average_density(const typename dealii::Triangulation<dim>::cell_iterator &cell,
                             const unsigned int                                        face,
                             const number                                              density);
 
    const dealii::Quadrature<dim> &
    get_face_center_quad();
 
    void
    synchronize_time_stepping();
 
  private:
    ScratchData<dim, dim, number> &scratch_data;
 
    dealii::TimerOutput timer;
 
    std::unique_ptr<adaflo::NavierStokes<dim>> navier_stokes;
 
    std::unique_ptr<dealii::Quadrature<dim>> face_center_quad;
 
    const adaflo::FlowParameters &adaflo_params;
 
    const bool do_evaporative_mass_flux;
 
    const TimeIntegration::TimeIterator<number> &time_iterator;
 
    unsigned int dof_index_u;
    unsigned int dof_index_p;
    unsigned int dof_index_hanging_nodes_u;
    unsigned int dof_index_parameters;
 
    unsigned int quad_index_u;
    unsigned int quad_index_p;
 
    dealii::DoFHandler<dim> dof_handler_parameters;
 
    dealii::AffineConstraints<number> constraints_parameters;
 
    mutable VectorType force_rhs_velocity_projected;
    mutable VectorType mass_balance_source_term_projected;
    mutable VectorType density;
    mutable VectorType viscosity;
 
    bool ready_for_time_advance = false;
 
    bool
    time_stepping_synchronized();
  };
} // namespace MeltPoolDG::Flow
#endif