refinement.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2019 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.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