reinitialization_elliptic_operator_fixed_point.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_system.h>
 
#include <deal.II/lac/generic_linear_algebra.h>
#include <deal.II/lac/la_parallel_block_vector.h>
 
#include <deal.II/matrix_free/fe_evaluation.h>
#include <deal.II/matrix_free/fe_point_evaluation.h>
#include <deal.II/matrix_free/matrix_free.h>
#include <deal.II/matrix_free/operators.h>
 
#include <meltpooldg/core/operator_base.hpp>
#include <meltpooldg/core/scratch_data.hpp>
#include <meltpooldg/level_set/reinitialization_data.hpp>
#include <meltpooldg/utilities/fe_integrator.hpp>
#include <meltpooldg/utilities/vector_tools.hpp>
 
 
namespace MeltPoolDG::LevelSet
{
  template <int dim, typename number>
  class ReinitializationEllipticOperator : public OperatorMatrixFree<dim, number>
  {
    using OperatorMatrixFree<dim, number>::vmult;
    using OperatorMatrixFree<dim, number>::create_rhs;
    using OperatorMatrixFree<dim, number>::compute_inverse_diagonal_from_matrixfree;
 
  public:
    using VectorType          = dealii::LinearAlgebra::distributed::Vector<number>;
    using VectorizedArrayType = dealii::VectorizedArray<number>;
    using MappingInfoType     = CutUtil::MappingInfoType<dim, number>;
    using PointEvaluationType = dealii::FEPointEvaluation<1, dim, dim, VectorizedArrayType>;
 
 
    ReinitializationEllipticOperator(
      const MeltPoolDG::ScratchData<dim, dim, number> &scratch_data_in,
      const ReinitializationData<number>              &reinit_data_in,
      const unsigned int                               reinit_dof_idx_in,
      const unsigned int                               reinit_quad_idx_in,
      const MappingInfoType                           &mapping_info_surface_in,
      const unsigned int                               ls_dof_idx_in);
 
 
    void
    vmult(VectorType &dst, const VectorType &src) const final;
 
    void
    create_rhs(VectorType &rhs, const VectorType &old_level_set) const final;
 
    void
    reinit() final;
 
    void
    compute_system_matrix_from_matrixfree(
      dealii::TrilinosWrappers::SparseMatrix &system_matrix) const final;
 
    void
    compute_inverse_diagonal_from_matrixfree(VectorType &diagonal) const final;
 
 
  private:
    void
    rhs_cell_operation(FECellIntegrator<dim, 1, number>       &cell_eval,
                       const FECellIntegrator<dim, 1, number> &psi_old) const;
 
    void
    interface_penalty_cell_operation(PointEvaluationType              &interface_penalty_surface,
                                     FECellIntegrator<dim, 1, number> &interface_penalty,
                                     const unsigned int                lane,
                                     const number                      penalty_coefficient) const;
 
    template <typename EvaluatorType>
    VectorizedArrayType
    evaluate_rhs_coefficient(const EvaluatorType &phi_old, const unsigned int q_index) const;
 
    void
    lhs_cell_operation(FECellIntegrator<dim, 1, number> &interface_penalty,
                       FECellIntegrator<dim, 1, number> &cell_eval,
                       PointEvaluationType              &interface_penalty_surface) const;
 
    void
    laplace_cell_operation(FECellIntegrator<dim, 1, number> &cell_eval) const;
 
    void
    lhs_inner_face_operation(FEFaceIntegrator<dim, 1, number> &eval_minus,
                             FEFaceIntegrator<dim, 1, number> &eval_plus) const;
 
    const ScratchData<dim, dim, number> &scratch_data;
 
    const ReinitializationData<number> &reinit_data;
 
    const unsigned int reinit_quad_idx;
 
    const MappingInfoType &mapping_info_surface;
 
    dealii::FE_Q<dim> fe_point_level_set;
 
    const unsigned int n_dofs_per_cell;
 
    const unsigned int ls_dof_idx;
 
    dealii::AlignedVector<dealii::VectorizedArray<number>> solution_old;
 
    VectorType zero_interface;
 
    number discontinuity_penalty = 0.0;
  };
} // namespace MeltPoolDG::LevelSet