refinement.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2019 - 2020 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;
 
namespace hp
{
  template <int dim, int 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 hp::DoFHandler<dim, spacedim> &dof_handler);
 
    template <int dim, int spacedim>
    void
    p_adaptivity_from_flags(const hp::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 hp::DoFHandler<dim, spacedim> &dof_handler,
      const Vector<Number> &               criteria,
      const Number                         p_refine_threshold,
      const Number                         p_coarsen_threshold,
      const ComparisonFunction<typename identity<Number>::type>
        &compare_refine = std::greater_equal<Number>(),
      const ComparisonFunction<typename identity<Number>::type>
        &compare_coarsen = std::less_equal<Number>());
 
    template <int dim, typename Number, int spacedim>
    void
    p_adaptivity_from_relative_threshold(
      const hp::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<typename identity<Number>::type>
        &compare_refine = std::greater_equal<Number>(),
      const ComparisonFunction<typename identity<Number>::type>
        &compare_coarsen = std::less_equal<Number>());
 
    template <int dim, typename Number, int spacedim>
    void
    p_adaptivity_fixed_number(
      const hp::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<typename identity<Number>::type>
        &compare_refine = std::greater_equal<Number>(),
      const ComparisonFunction<typename identity<Number>::type>
        &compare_coarsen = std::less_equal<Number>());
 
    template <int dim, typename Number, int spacedim>
    void
    p_adaptivity_from_regularity(
      const hp::DoFHandler<dim, spacedim> &dof_handler,
      const Vector<Number> &               sobolev_indices);
 
    template <int dim, typename Number, int spacedim>
    void
    p_adaptivity_from_reference(
      const hp::DoFHandler<dim, spacedim> &                      dof_handler,
      const Vector<Number> &                                     criteria,
      const Vector<Number> &                                     references,
      const ComparisonFunction<typename identity<Number>::type> &compare_refine,
      const ComparisonFunction<typename identity<Number>::type>
        &compare_coarsen);
    template <int dim, typename Number, int spacedim>
    void
    predict_error(const hp::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 hp::DoFHandler<dim, spacedim> &dof_handler);
 
    template <int dim, int spacedim>
    void
    choose_p_over_h(const hp::DoFHandler<dim, spacedim> &dof_handler);
 
  } // namespace Refinement
} // namespace hp
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif // dealii_hp_refinement_h