reinitialization_olsson_DG_operator.hpp

Go to the documentation of this file.

#pragma once
 
#include <meltpooldg/level_set/reinitialization_DG_diffusion_operator.hpp>
#include <meltpooldg/level_set/reinitialization_DG_grad_operator.hpp>
#include <meltpooldg/time_integration/solution_history.hpp>
#include <meltpooldg/time_integration/time_integrator_base.hpp>
#include <meltpooldg/utilities/fe_integrator.hpp>
 
namespace MeltPoolDG::LevelSet
{
 
  template <int dim, typename number>
  class OlssonDGOperator
  {
  public:
    using VectorType      = dealii::LinearAlgebra::distributed::Vector<number>;
    using BlockVectorType = dealii::LinearAlgebra::distributed::BlockVector<number>;
 
    OlssonDGOperator(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 VectorType                                &curvature_in,
                     const BlockVectorType                           &normal_vector_in);
 
 
    void
    prepare_operator(const VectorType &solution);
 
    void
    apply_operator(number const                                           time,
                   VectorType                                            &dst,
                   VectorType const                                      &src,
                   const std::function<void(unsigned int, unsigned int)> &func) const;
 
    void
    apply_dirichlet_boundary_operator([[maybe_unused]] number const      time,
                                      [[maybe_unused]] VectorType       &dst,
                                      [[maybe_unused]] VectorType const &src) const {};
    void
    reinit();
 
    void
    apply_diffusion_implicit(
      number const                                                   time,
      number const                                                   time_step,
      [[maybe_unused]] TimeIntegration::SolutionHistory<VectorType> &solution_history) const;
 
    bool update_field_functions = true;
 
    void
    set_field_functions([[maybe_unused]] number const time) const {};
 
    number
    get_max_diffusitivity() const;
 
    VectorType &
    get_signum_smoothed() const
    {
      return signum_smoothed;
    }
 
    VectorType &
    get_sign_indicator_function()
    {
      return sign_indicator_function;
    }
 
    void
    set_artificial_diffusitivity();
 
  private:
    const MeltPoolDG::ScratchData<dim, dim, number> &scratch_data;
 
    const unsigned int reinit_dof_idx;
    const unsigned int reinit_quad_idx;
 
    const ReinitializationData<number> &reinit_data;
 
    mutable VectorType num_Hamiltonian;
    mutable VectorType signum_smoothed;
    mutable VectorType God_grad;
    mutable VectorType sign_indicator_function;
 
    // auxiliary vectors for Godunov's scheme
    mutable VectorType grad_x_l;
    mutable VectorType grad_x_r;
    mutable VectorType grad_y_l;
    mutable VectorType grad_y_r;
    mutable VectorType grad_z_l;
    mutable VectorType grad_z_r;
 
    ReinitializationDGDiffusionOperator<dim, number> RI_DG_diffusion_operator;
    mutable RIGradOperator<dim, number>              RI_grad_operator;
 
 
    std::shared_ptr<TimeIntegration::TimeIntegratorBase<number>> IMEX_integration;
 
 
    void
    compute_godunov_hamiltonian(const VectorType &solution) const;
 
    void
    compute_godunov_gradient(const VectorType &solution) const;
 
    void
    compute_smoothed_signum(const VectorType &solution, const number min_vertex_distance) const;
 
    void
    interface_movement_penalty(const dealii::MatrixFree<dim, number>       &data,
                               VectorType                                  &dst,
                               const VectorType                            &src,
                               const std::pair<unsigned int, unsigned int> &cell_range) const;
 
    void
    local_apply_domain_num_Hamiltonian(
      const dealii::MatrixFree<dim, number>       &data,
      VectorType                                  &dst,
      const VectorType                            &src,
      const std::pair<unsigned int, unsigned int> &cell_range) const;
  };
} // namespace MeltPoolDG::LevelSet