reinitialization_elliptic_operation.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/non_matching/mesh_classifier.h>
 
#include <meltpooldg/core/scratch_data.hpp>
#include <meltpooldg/cut/util.hpp>
#include <meltpooldg/level_set/normal_vector_operation.hpp>
#include <meltpooldg/level_set/reinitialization_elliptic_operator.hpp>
#include <meltpooldg/level_set/reinitialization_operation_base.hpp>
#include <meltpooldg/linear_algebra/preconditioner.hpp>
 
namespace MeltPoolDG::LevelSet
{
  template <int dim, typename number>
  class ReinitializationEllipticOperation : public ReinitializationOperationBase<dim, number>
  {
  public:
    using VectorType      = dealii::LinearAlgebra::distributed::Vector<number>;
    using MappingInfoType = CutUtil::MappingInfoType<dim, number>;
 
    ReinitializationEllipticOperation(const ScratchData<dim, dim, number> &scratch_data_in,
                                      const ReinitializationData<number>  &reinit_data,
                                      const unsigned int                   reinit_dof_idx_in,
                                      const unsigned int                   reinit_quad_idx_in,
                                      const unsigned int                   ls_dof_idx_in);
 
    void
    solve() override;
 
    void
    solve_one_iter();
 
    void
    reinit() override;
 
    void
    set_initial_condition(const VectorType &solution_level_set_in) override;
 
    void
    set_initial_condition(const dealii::Function<dim> &initial_field_function) override;
 
    const VectorType &
    get_level_set() const override;
 
    VectorType &
    get_level_set() override;
 
    void
    attach_vectors(
      std::vector<dealii::LinearAlgebra::distributed::Vector<number> *> &vectors) override;
 
    void
    attach_output_vectors(GenericDataOut<dim, number> &data_out) const override;
 
    number
    get_relative_change_level_set() const;
 
  private:
    void
    compute_intersected_quadrature();
 
    MappingInfoType mapping_info_surface;
 
    std::shared_ptr<dealii::NonMatching::MeshClassifier<dim>> mesh_classifier;
 
    void
    create_operator();
 
    const ScratchData<dim, dim, number> &scratch_data;
 
    const ReinitializationData<number> reinit_data;
 
    mutable unsigned int reinit_dof_idx;
    const unsigned int   reinit_quad_idx;
    const unsigned int   ls_dof_idx;
 
    VectorType solution_level_set;
    VectorType rhs;
    // level set field from the previous step: initial condition
    VectorType level_set_old;
 
    std::unique_ptr<ReinitializationEllipticOperator<dim, number>> reinit_operator;
    Preconditioner<dim, VectorType, number> preconditioner;
 
    number relative_change_level_set = std::numeric_limits<number>::max();
 
    VectorType level_set_old_locally_owned;
  };
} // namespace MeltPoolDG::LevelSet