solution_transfer.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/conditional_ostream.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/grid/tria.h>
 
#include <deal.II/lac/affine_constraints.h>
#include <deal.II/lac/la_parallel_vector.h>
 
#include <deal.II/non_matching/mesh_classifier.h>
 
#include <meltpooldg/cut/cut_data.hpp>
#include <meltpooldg/utilities/attach_vectors.hpp>
 
#include <functional>
#include <vector>
 
 
namespace MeltPoolDG::CutUtil
{
  template <int dim, typename Number>
  class SolutionTransferOperator
  {
  public:
    using VectorType = dealii::LinearAlgebra::distributed::Vector<Number>;
 
    SolutionTransferOperator(const GhostPenaltyData<Number> &ghost_penalty_in,
                             const bool                      is_two_phase,
                             const int                       verbosity = 0);
 
    void
    reinit(dealii::DoFHandler<dim>                               &cut_dof_handler,
           dealii::Triangulation<dim>                            &tria,
           const VectorType                                      &cut_solution,
           const dealii::NonMatching::MeshClassifier<dim>        &mesh_classifier_old,
           const dealii::NonMatching::MeshClassifier<dim>        &mesh_classifier,
           const std::function<void(VectorType &)>               &reinit_cut_vector,
           const std::function<void()>                           &setup_dof_system,
           const AttachDoFHandlerAndVectorsType<dim, VectorType> &attach_vectors = {});
 
    void
    reinit(dealii::DoFHandler<dim>                               &cut_dof_handler,
           dealii::Triangulation<dim>                            &tria,
           const std::vector<const VectorType *>                 &cut_solutions,
           const dealii::NonMatching::MeshClassifier<dim>        &mesh_classifier_old,
           const dealii::NonMatching::MeshClassifier<dim>        &mesh_classifier,
           const std::function<void(VectorType &)>               &reinit_cut_vector,
           const std::function<void()>                           &setup_dof_system,
           const AttachDoFHandlerAndVectorsType<dim, VectorType> &attach_vectors = {});
 
    const std::vector<VectorType> &
    get_updated_solutions() const
    {
      return new_solutions;
    }
 
    std::vector<VectorType> &
    get_updated_solutions()
    {
      return new_solutions;
    }
 
    const VectorType &
    get_updated_solution() const
    {
      Assert(
        new_solutions.size() == 1,
        dealii::ExcMessage(
          "This function assumes that only one cut solution vector was attached, which is not the case."));
      return new_solutions[0];
    }
 
    VectorType &
    get_updated_solution()
    {
      Assert(
        new_solutions.size() == 1,
        dealii::ExcMessage(
          "This function assumes that only one cut solution vector was attached, which is not the case."));
      return new_solutions[0];
    }
 
  private:
    std::vector<VectorType> new_solutions;
 
    unsigned int fe_degree;
 
    unsigned int n_components_per_phase;
 
    bool is_dg;
 
    const GhostPenaltyData<Number> ghost_penalty;
 
    const bool is_two_phase;
 
    const unsigned int verbosity;
 
    dealii::ConditionalOStream pcout;
 
    void
    transfer_solution_constant_dofs(
      dealii::DoFHandler<dim>                               &cut_dof_handler,
      dealii::Triangulation<dim>                            &tria,
      const std::vector<const VectorType *>                 &cut_solutions,
      const dealii::NonMatching::MeshClassifier<dim>        &mesh_classifier_old,
      const dealii::NonMatching::MeshClassifier<dim>        &mesh_classifier,
      const std::function<void(VectorType &)>               &reinit_cut_vector,
      const std::function<void()>                           &setup_dof_system,
      const AttachDoFHandlerAndVectorsType<dim, VectorType> &attach_vectors = {});
 
    VectorType
    mark_dofs_for_gp_extrapolation(
      const dealii::DoFHandler<dim>                  &cut_dof_handler,
      const dealii::NonMatching::MeshClassifier<dim> &mesh_classifier,
      const dealii::NonMatching::MeshClassifier<dim> &mesh_classifier_old) const;
 
    dealii::AffineConstraints<Number>
    create_constraints_gp_extrapolation(const dealii::DoFHandler<dim> &cut_dof_handler,
                                        const VectorType &flags_dofs_gp_extrapolation) const;
 
    void
    extrapolate_solution_new_dofs(
      const dealii::DoFHandler<dim>                  &cut_dof_handler,
      const dealii::NonMatching::MeshClassifier<dim> &mesh_classifier,
      const dealii::NonMatching::MeshClassifier<dim> &mesh_classifier_old,
      const std::function<void(VectorType &)>        &reinit_vector);
  };
} // namespace MeltPoolDG::CutUtil