advection_DG_operator.hpp

Go to the documentation of this file.

#pragma once
 
/* Code adapted from:
https://github.com/kronbichler/advection_miniapp/blob/master/advection_solver_variable.cc*/
 
#include <deal.II/base/function.h>
#include <deal.II/base/vectorization.h>
 
#include <deal.II/lac/la_parallel_vector.h>
 
#include <deal.II/matrix_free/operators.h>
 
#include <deal.II/numerics/vector_tools.h>
 
#include <meltpooldg/core/boundary_conditions.hpp>
#include <meltpooldg/core/scratch_data.hpp>
#include <meltpooldg/utilities/fe_integrator.hpp>
#include <meltpooldg/utilities/vector_tools.hpp>
 
#include <cmath>
 
namespace MeltPoolDG::LevelSet
{
  template <int dim, typename number>
  class AdvectionDGOperator
  {
  public:
    using VectorType      = dealii::LinearAlgebra::distributed::Vector<number>;
    using BlockVectorType = dealii::LinearAlgebra::distributed::BlockVector<number>;
 
    using scalar = dealii::VectorizedArray<number>;
    using vector = dealii::Tensor<1, dim, scalar>;
 
    AdvectionDGOperator(const MeltPoolDG::ScratchData<dim, dim, number> &scratch_data_in,
                        const unsigned int                               advec_diff_dof_idx_in,
                        const unsigned int                               advec_diff_quad_idx_in,
                        const std::shared_ptr<MeltPoolDG::BoundaryConditionManager<dim, number>>
                          &boundary_conditions_in);
    void
    set_advection_velocity_function(
      const std::shared_ptr<dealii::Function<dim, number>> &advection_velocity_function_in);
 
    void
    set_advection_velocity(const VectorType  &advection_velocity_in,
                           const unsigned int velocity_dof_idx_in);
 
    void
    update_time_velocity_function(const number time) const;
 
 
    void
    apply_operator(number                                                 time,
                   VectorType                                            &dst,
                   const VectorType                                      &src,
                   const std::function<void(unsigned int, unsigned int)> &func = {}) const;
    void
    apply_dirichlet_boundary_operator(const number      time,
                                      VectorType       &dst,
                                      const VectorType &src) const;
 
    bool update_field_functions;
 
 
  private:
    const MeltPoolDG::ScratchData<dim, dim, number> &scratch_data_;
 
    const unsigned int advec_diff_dof_idx  = 0;
    const unsigned int advec_diff_quad_idx = 0;
 
    std::shared_ptr<MeltPoolDG::BoundaryConditionManager<dim, number>> boundary_conditions;
 
    const VectorType *advection_velocity_ = nullptr;
    unsigned int      velocity_dof_idx    = dealii::numbers::invalid_unsigned_int;
    std::shared_ptr<dealii::Function<dim, number>> advection_velocity_function = nullptr;
 
    void
    local_apply_domain(const dealii::MatrixFree<dim, number>       &data,
                       VectorType                                  &dst,
                       const VectorType                            &src,
                       const std::pair<unsigned int, unsigned int> &cell_range) const;
 
    void
    local_apply_domain_dummy(
      [[maybe_unused]] const dealii::MatrixFree<dim, number>       &data,
      [[maybe_unused]] VectorType                                  &dst,
      [[maybe_unused]] const VectorType                            &src,
      [[maybe_unused]] const std::pair<unsigned int, unsigned int> &cell_range) const {};
 
    void
    local_apply_inner_face(const dealii::MatrixFree<dim, number>       &data,
                           VectorType                                  &dst,
                           const VectorType                            &src,
                           const std::pair<unsigned int, unsigned int> &cell_range) const;
 
 
    void
    local_apply_inner_face_dummy(
      [[maybe_unused]] const dealii::MatrixFree<dim, number>       &data,
      [[maybe_unused]] VectorType                                  &dst,
      [[maybe_unused]] const VectorType                            &src,
      [[maybe_unused]] const std::pair<unsigned int, unsigned int> &cell_range) const {};
 
    void
    local_apply_homogenous_boundary_face(
      const dealii::MatrixFree<dim, number>       &data,
      VectorType                                  &dst,
      const VectorType                            &src,
      const std::pair<unsigned int, unsigned int> &cell_range) const;
 
    void
    local_apply_inhomogenous_boundary_face(
      [[maybe_unused]] const dealii::MatrixFree<dim, number>       &data,
      [[maybe_unused]] VectorType                                  &dst,
      [[maybe_unused]] const VectorType                            &src,
      [[maybe_unused]] const std::pair<unsigned int, unsigned int> &cell_range) const;
  };
} // namespace MeltPoolDG::LevelSet