amr.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/grid/tria.h>
 
#include <meltpooldg/utilities/amr_data.hpp>
#include <meltpooldg/utilities/attach_vectors.hpp>
 
#include <functional>
#include <vector>
 
 
namespace MeltPoolDG::AMR
{
  template <int dim>
  using MarkCellsForRefinementType = std::function<bool(dealii::Triangulation<dim> &)>;
 
  template <typename number>
  inline bool
  now(const AdaptiveMeshingData<number> &amr, const int n_time_step)
  {
    return not(n_time_step % amr.every_n_step) or n_time_step == 0;
  }
 
  template <int dim, typename VectorType, typename number = typename VectorType::value_type>
  void
  refine_grid(const MarkCellsForRefinementType<dim>                 &mark_cells_for_refinement,
              const AttachDoFHandlerAndVectorsType<dim, VectorType> &attach_vectors,
              const std::function<void()>                           &setup_dof_system,
              const AdaptiveMeshingData<number>                     &amr,
              dealii::Triangulation<dim>                            &tria,
              const int                                              n_time_step,
              const std::function<void()>                           &post = std::function<void()>(),
              const std::function<void()>                           &pre = std::function<void()>());
 
  template <int dim, typename VectorType, typename number>
  void
  refine_grid(const std::function<bool(dealii::Triangulation<dim> &)> &mark_cells_for_refinement,
              const std::function<void(std::vector<VectorType *> &)>  &attach_vectors,
              const std::function<void()>                             &setup_dof_system,
              const AdaptiveMeshingData<number>                       &amr,
              dealii::DoFHandler<dim>                                 &dof_handler,
              const int                                                n_time_step,
              const std::function<void()> &post = std::function<void()>(),
              const std::function<void()> &pre  = std::function<void()>());
 
  template <int dim, typename number>
  bool
  mark_fixed_number(dealii::Triangulation<dim>        &tria,
                    const dealii::Vector<number>      &indicator,
                    const AdaptiveMeshingData<number> &amr_data,
                    dealii::types::global_cell_index   max_n_cells =
                      std::numeric_limits<dealii::types::global_cell_index>::max());
 
  template <int dim, typename number>
  bool
  mark_fixed_fraction(dealii::Triangulation<dim>        &tria,
                      const dealii::Vector<number>      &indicator,
                      const AdaptiveMeshingData<number> &amr_data);
 
  namespace internal
  {
    // Limit the maximum and minimum refinement levels of cells of the grid and do not
    // coarsen/refine cells along boundary
    // TODO use this function within mark_cells_for_refinement
    template <int dim, typename number>
    void
    limit_amr(dealii::Triangulation<dim> &tria, const AdaptiveMeshingData<number> &amr_data);
 
    template <int dim, typename number>
    void
    clear_refine_flags_below_threshold(dealii::Triangulation<dim>   &tria,
                                       const dealii::Vector<number> &indicator,
                                       number                        threshold);
 
    template <int dim>
    bool
    do_refine_based_on_n_marked_cells(const dealii::Triangulation<dim> &tria,
                                      unsigned                          min_cells = 1);
  } // namespace internal
} // namespace MeltPoolDG::AMR