helmholtz_DG_operator.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/vectorization.h>
 
#include <deal.II/lac/la_parallel_vector.h>
#include <deal.II/lac/trilinos_sparse_matrix.h>
#include <deal.II/lac/trilinos_sparsity_pattern.h>
 
#include <deal.II/matrix_free/matrix_free.h>
 
#include <meltpooldg/core/scratch_data.hpp>
#include <meltpooldg/linear_algebra/linear_solver_data.hpp>
#include <meltpooldg/linear_algebra/preconditioner.hpp>
#include <meltpooldg/utilities/utility_functions.hpp>
#include <meltpooldg/utilities/vector_tools.hpp>
 
#include <memory>
#include <utility>
 
 
namespace MeltPoolDG::LevelSet
{
  template <int dim, typename number>
  class HelmholtzDGOperator
  {
  private:
    using VectorType          = dealii::LinearAlgebra::distributed::Vector<number>;
    using SparseMatrixType    = dealii::TrilinosWrappers::SparseMatrix;
    using SparsityPatternType = dealii::TrilinosWrappers::SparsityPattern;
 
  public:
    HelmholtzDGOperator(const ScratchData<dim, dim, number> &scratch_data_in,
                        const unsigned int                   dof_idx_in,
                        const unsigned int                   quad_idx_in,
                        const number                         filter_parameter_in,
                        const number                         interior_penalty_parameter_in,
                        const PreconditionerType             preconditioner_type_in);
    void
    vmult(dealii::LinearAlgebra::distributed::Vector<number>       &dst,
          const dealii::LinearAlgebra::distributed::Vector<number> &src) const;
 
    void
    reinit() const;
 
    const SparseMatrixType &
    get_system_matrix() const
    {
      return this->system_matrix;
    }
 
    const Preconditioner<dim, VectorType, number> &
    get_preconditioner() const
    {
      return this->preconditioner;
    }
 
  private:
    const ScratchData<dim, dim, number> &scratch_data;
 
    const unsigned int dof_idx;
    const unsigned int quad_idx;
 
    mutable dealii::AlignedVector<dealii::VectorizedArray<number>> damping;
    mutable dealii::AlignedVector<dealii::VectorizedArray<number>> array_penalty_parameter;
 
    const number filter_parameter;
    const number interior_penalty_parameter;
 
    mutable SparseMatrixType system_matrix;
 
    mutable Preconditioner<dim, VectorType, number> preconditioner;
 
    const PreconditionerType preconditioner_type;
 
 
    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_inner_face(const dealii::MatrixFree<dim, number>       &data,
                           VectorType                                  &dst,
                           const VectorType                            &src,
                           const std::pair<unsigned int, unsigned int> &face_range) const;
 
    void
    local_apply_boundary_face(const dealii::MatrixFree<dim, number>       &data,
                              VectorType                                  &dst,
                              const VectorType                            &src,
                              const std::pair<unsigned int, unsigned int> &face_range) const;
 
    void
    do_cell_integral_local(FECellIntegrator<dim, 1, number> &cell_integrator) const;
 
    void
    do_face_integral_local(FEFaceIntegrator<dim, 1, number> &face_integrator_minus,
                           FEFaceIntegrator<dim, 1, number> &face_integrator_plus) const;
 
    void
    do_bounary_integral_local(FEFaceIntegrator<dim, 1, number> &face_integrator_minus) const;
 
    void
    build_matrix() const;
  };
} // namespace  MeltPoolDG::LevelSet