reinitialization_hyperbolic_DG_operation.hpp

Go to the documentation of this file.

#pragma once
 
#include <meltpooldg/core/scratch_data.hpp>
#include <meltpooldg/level_set/curvature_DG_operation.hpp>
#include <meltpooldg/level_set/normal_vector_DG_operation.hpp>
#include <meltpooldg/level_set/reinitialization_olsson_DG_operator.hpp>
#include <meltpooldg/level_set/reinitialization_operation_base.hpp>
#include <meltpooldg/time_integration/solution_history.hpp>
#include <meltpooldg/time_integration/time_iterator.hpp>
 
 
 
namespace MeltPoolDG::LevelSet
{
 
  template <int dim, typename number>
  class ReinitializationHyperbolicDGOperation
    : public ReinitializationOperationBase<dim, number>,
      public ReinitializationHyperbolicOperationCapable<dim, number>
  {
  private:
    using VectorType      = dealii::LinearAlgebra::distributed::Vector<number>;
    using BlockVectorType = dealii::LinearAlgebra::distributed::BlockVector<number>;
 
  public:
    ReinitializationHyperbolicDGOperation(
      const ScratchData<dim, dim, number>         &scratch_data_in,
      const ReinitializationData<number>          &reinit_data,
      const TimeIntegration::TimeIterator<number> &time_iterator,
      const unsigned int                           reinit_dof_idx_in,
      const unsigned int                           reinit_quad_idx_in,
      const unsigned int                           ls_dof_idx_in,
      const NormalVectorData<number>              &normal_vec_data,
      const CurvatureData<number>                 &curvature_data);
    ReinitializationHyperbolicDGOperation(
      const ScratchData<dim, dim, number>                           &scratch_data_in,
      const ReinitializationData<number>                            &reinit_data,
      const TimeIntegration::TimeIterator<number>                   &time_iterator,
      const unsigned int                                             reinit_dof_idx_in,
      const unsigned int                                             reinit_quad_idx_in,
      const unsigned int                                             ls_dof_idx_in,
      const std::shared_ptr<NormalVectorOperationBase<dim, number>> &normal_vector_operation_in,
      const std::shared_ptr<CurvatureDGOperation<dim, number>>      &curvature_operation_in,
      const bool                                                     is_coupled_in);
 
    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;
 
    void
    init_time_advance();
 
    void
    solve() override;
 
    number
    get_max_change_level_set() const final;
 
    const BlockVectorType &
    get_normal_vector() const;
 
    const VectorType &
    get_level_set() const override;
 
    VectorType &
    get_level_set() override;
 
    BlockVectorType &
    get_normal_vector();
 
    void
    attach_vectors(
      std::vector<dealii::LinearAlgebra::distributed::Vector<number> *> &vectors) override;
 
    void
    attach_output_vectors(GenericDataOut<dim, number> &data_out) const override;
 
    number
    compute_CFL_based_timestep() const override;
 
    void
    set_artificial_diffusitivity() override;
 
    VectorType *
    get_sign_indicator_function() override
    {
      return &reinit_DG_operator->get_sign_indicator_function();
    }
 
  private:
    const ScratchData<dim, dim, number>         &scratch_data;
    const ReinitializationData<number>           reinit_data;
    const TimeIntegration::TimeIterator<number> &time_iterator;
    /*
     *  Based on the following indices the correct DoFHandler or quadrature rule from
     *  ScratchData<dim,dim,number> object is selected. This is important when
     * ScratchData<dim,dim,number> holds multiple DoFHandlers, quadrature rules, etc.
     */
    mutable unsigned int reinit_dof_idx;
    const unsigned int   reinit_quad_idx;
    const unsigned int   ls_dof_idx;
 
    TimeIntegration::SolutionHistory<VectorType> solution_history;
 
    std::shared_ptr<OlssonDGOperator<dim, number>> reinit_DG_operator;
 
    std::shared_ptr<TimeIntegration::TimeIntegratorBase<number>> reinitialization_integration;
 
 
    // maximum change of the level set due to the current reinitialization step
    number max_change_level_set = std::numeric_limits<number>::max();
 
    /*
     *   Computation of the normal vectors
     */
    std::shared_ptr<NormalVectorOperationBase<dim, number>> normal_vector_operation;
 
    /*
     *   Computation of the curvature
     */
    std::shared_ptr<CurvatureDGOperation<dim, number>> curvature_operation;
 
    const bool is_coupled = false;
  };
} // namespace MeltPoolDG::LevelSet