advection_diffusion_operation.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/lac/generic_linear_algebra.h>
 
#include <meltpooldg/core/boundary_conditions.hpp>
#include <meltpooldg/core/operator_base.hpp>
#include <meltpooldg/level_set/advection_diffusion_operation_base.hpp>
#include <meltpooldg/level_set/advection_diffusion_operator.hpp>
#include <meltpooldg/linear_algebra/preconditioner.hpp>
#include <meltpooldg/linear_algebra/predictor.hpp>
#include <meltpooldg/post_processing/generic_data_out.hpp>
#include <meltpooldg/time_integration/solution_history.hpp>
#include <meltpooldg/time_integration/time_iterator.hpp>
#include <meltpooldg/utilities/constraints.hpp>
 
namespace MeltPoolDG::LevelSet
{
  template <int dim, typename number>
  class AdvectionDiffusionOperation : public AdvectionDiffusionOperationBase<dim, number>
  {
  private:
    using VectorType       = dealii::LinearAlgebra::distributed::Vector<number>;
    using BlockVectorType  = dealii::LinearAlgebra::distributed::BlockVector<number>;
    using SparseMatrixType = dealii::TrilinosWrappers::SparseMatrix;
 
  public:
    /*
     *  All the necessary parameters are stored in this struct.
     */
 
    AdvectionDiffusionOperation(
      const ScratchData<dim, dim, number> &scratch_data_in,
      const std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>>
                                                  &dirichlet_bc_in,
      const AdvectionDiffusionData<number>        &advec_diff_data_in,
      const TimeIntegration::TimeIterator<number> &time_iterator,
      const unsigned int                           advec_diff_dof_idx_in,
      const unsigned int                           advec_diff_hanging_nodes_dof_idx_in,
      const unsigned int                           advec_diff_quad_idx_in);
 
    void
    set_initial_condition(const dealii::Function<dim> &initial_field_function) override;
 
    virtual void
    set_advection_velocity(const VectorType  &advection_velocity,
                           const unsigned int velocity_dof_idx) final;
 
    virtual void
    set_advection_velocity_function(
      const std::shared_ptr<dealii::Function<dim, number>> &advection_velocity) final;
 
    void
    set_inflow_outflow_bc(
      const std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>>
        inflow_outflow_bc_);
 
    void
    setup_constraints(
      ScratchData<dim, dim, number>         &mutable_scratch_data,
      const PeriodicBoundaryConditions<dim> &periodic_bc,
      const std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>>
        &dirichlet_bc_in) final;
 
    void
    reinit() override;
 
    void
    init_time_advance() override;
 
    void
    solve(const bool do_finish_time_step = true) override;
 
    void
    attach_vectors(
      std::vector<dealii::LinearAlgebra::distributed::Vector<number> *> &vectors) override;
 
    void
    attach_output_vectors(GenericDataOut<dim, number> &data_out) const override;
 
    const dealii::LinearAlgebra::distributed::Vector<number> &
    get_advected_field() const override;
 
    dealii::LinearAlgebra::distributed::Vector<number> &
    get_advected_field() override;
 
    const dealii::LinearAlgebra::distributed::Vector<number> &
    get_advected_field_old() const override;
 
    dealii::LinearAlgebra::distributed::Vector<number> &
    get_advected_field_old() override;
 
    dealii::LinearAlgebra::distributed::Vector<number> &
    get_user_rhs() override;
 
    const dealii::LinearAlgebra::distributed::Vector<number> &
    get_user_rhs() const override;
 
  private:
    void
    create_operator();
 
    void
    create_inflow_outflow_constraints();
 
    void
    commit_solution_history_and_compute_predictor();
 
    const ScratchData<dim, dim, number> &scratch_data;
 
    const std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>>
      &dirichlet_bc;
 
    std::unique_ptr<AdvectionDiffusionOperator<dim, number>> advec_diff_operator;
 
    const TimeIntegration::TimeIterator<number> &time_iterator;
    /*
     *  Based on the following indices the correct DoFHandler or quadrature rule from
     *  ScratchData<dim,dim,number> object is selected. This is important when
     * ScratchData<dim,dim,number> holds multiple DoFHandlers, quadrature rules, etc.
     */
    const unsigned int advec_diff_dof_idx               = 0;
    const unsigned int advec_diff_quad_idx              = 0;
    const unsigned int advec_diff_hanging_nodes_dof_idx = dealii::numbers::invalid_unsigned_int;
    std::shared_ptr<dealii::Function<dim, number>> advection_velocity_function = nullptr;
 
    const dealii::LinearAlgebra::distributed::Vector<number> *advection_velocity = nullptr;
 
    unsigned int velocity_dof_idx = dealii::numbers::invalid_unsigned_int;
 
    TimeIntegration::SolutionHistory<VectorType> solution_history;
 
    std::unique_ptr<Predictor<VectorType, number>> predictor;
 
    VectorType solution_advected_field_extrapolated;
 
    Preconditioner<dim, VectorType, number> preconditioner;
 
    VectorType rhs;
 
    VectorType user_rhs;
 
    bool update_ghosts = false;
 
    std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>> inflow_outflow_bc;
 
    std::pair<std::vector<unsigned int>, std::vector<number>> inflow_constraints_indices_and_values;
  };
} // namespace MeltPoolDG::LevelSet