reinitialization_elliptic_operation_CG_newton.hpp

Go to the documentation of this file.

#pragma once
 
#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_CG_newton.hpp>
#include <meltpooldg/level_set/reinitialization_operation_base.hpp>
#include <meltpooldg/linear_algebra/newton_raphson_solver.hpp>
#include <meltpooldg/linear_algebra/preconditioner.hpp>
 
#include <limits>
 
namespace MeltPoolDG::LevelSet
{
  template <int dim, typename number>
  class ReinitializationEllipticOperationNewton : public ReinitializationOperationBase<dim, number>
  {
  public:
    using VectorType      = dealii::LinearAlgebra::distributed::Vector<number>;
    using MappingInfoType = CutUtil::MappingInfoType<dim, number>;
 
    ReinitializationEllipticOperationNewton(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;
 
    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;
    // level set update from the new Newton-Raphson iteration
    VectorType delta_level_set;
 
    std::unique_ptr<ReinitializationEllipticOperatorNewton<dim, number>> reinit_operator;
    Preconditioner<dim, VectorType, number> preconditioner;
 
    number relative_change_level_set = std::numeric_limits<number>::max();
 
    NewtonRaphsonSolver<number, VectorType> newton;
 
    void
    setup_newton();
  };
} // namespace MeltPoolDG::LevelSet