refinement.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2019 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_hp_refinement_h
#define dealii_hp_refinement_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/template_constraints.h>
 
#include <functional>
#include <vector>
 
 
DEAL_II_NAMESPACE_OPEN
 
 
// forward declarations
#ifndef DOXYGEN
template <typename Number>
class Vector;
 
template <int dim, int spacedim>
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
class DoFHandler;
#endif
 
 
namespace hp
{
  namespace Refinement
  {
    template <typename Number>
    using ComparisonFunction =
      std::function<bool(const Number &, const Number &)>;
 
    template <int dim, int spacedim>
    void
    full_p_adaptivity(const DoFHandler<dim, spacedim> &dof_handler);
 
    template <int dim, int spacedim>
    void
    p_adaptivity_from_flags(const DoFHandler<dim, spacedim> &dof_handler,
                            const std::vector<bool> &        p_flags);
 
    template <int dim, typename Number, int spacedim>
    void
    p_adaptivity_from_absolute_threshold(
      const DoFHandler<dim, spacedim> &dof_handler,
      const Vector<Number> &           criteria,
      const Number                     p_refine_threshold,
      const Number                     p_coarsen_threshold,
      const ComparisonFunction<std_cxx20::type_identity_t<Number>>
        &compare_refine = std::greater_equal<Number>(),
      const ComparisonFunction<std_cxx20::type_identity_t<Number>>
        &compare_coarsen = std::less_equal<Number>());
 
    template <int dim, typename Number, int spacedim>
    void
    p_adaptivity_from_relative_threshold(
      const DoFHandler<dim, spacedim> &dof_handler,
      const Vector<Number> &           criteria,
      const double                     p_refine_fraction  = 0.5,
      const double                     p_coarsen_fraction = 0.5,
      const ComparisonFunction<std_cxx20::type_identity_t<Number>>
        &compare_refine = std::greater_equal<Number>(),
      const ComparisonFunction<std_cxx20::type_identity_t<Number>>
        &compare_coarsen = std::less_equal<Number>());
 
    template <int dim, typename Number, int spacedim>
    void
    p_adaptivity_fixed_number(
      const DoFHandler<dim, spacedim> &dof_handler,
      const Vector<Number> &           criteria,
      const double                     p_refine_fraction  = 0.5,
      const double                     p_coarsen_fraction = 0.5,
      const ComparisonFunction<std_cxx20::type_identity_t<Number>>
        &compare_refine = std::greater_equal<Number>(),
      const ComparisonFunction<std_cxx20::type_identity_t<Number>>
        &compare_coarsen = std::less_equal<Number>());
 
    template <int dim, typename Number, int spacedim>
    void
    p_adaptivity_from_regularity(const DoFHandler<dim, spacedim> &dof_handler,
                                 const Vector<Number> &sobolev_indices);
 
    template <int dim, typename Number, int spacedim>
    void
    p_adaptivity_from_reference(
      const DoFHandler<dim, spacedim> &dof_handler,
      const Vector<Number> &           criteria,
      const Vector<Number> &           references,
      const ComparisonFunction<std_cxx20::type_identity_t<Number>>
        &compare_refine,
      const ComparisonFunction<std_cxx20::type_identity_t<Number>>
        &compare_coarsen);
 
    template <int dim, typename Number, int spacedim>
    void
    predict_error(const DoFHandler<dim, spacedim> &dof_handler,
                  const Vector<Number> &           error_indicators,
                  Vector<Number> &                 predicted_errors,
                  const double                     gamma_p = std::sqrt(0.4),
                  const double                     gamma_h = 2.,
                  const double                     gamma_n = 1.);
 
    template <int dim, int spacedim>
    void
    force_p_over_h(const DoFHandler<dim, spacedim> &dof_handler);
 
    template <int dim, int spacedim>
    void
    choose_p_over_h(const DoFHandler<dim, spacedim> &dof_handler);
 
    template <int dim, int spacedim>
    bool
    limit_p_level_difference(const DoFHandler<dim, spacedim> &dof_handler,
                             const unsigned int max_difference    = 1,
                             const unsigned int contains_fe_index = 0);
 
  } // namespace Refinement
} // namespace hp
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif // dealii_hp_refinement_h