From b4e48502314326d489b1565eb7acf7da5d20f6c9 Mon Sep 17 00:00:00 2001 From: Marc Fehling Date: Thu, 19 Nov 2020 13:53:31 -0700 Subject: [PATCH] Prefer hyphen for the h, p, hp terms in the documentation. --- doc/doxygen/headers/constraints.h | 8 +-- doc/doxygen/headers/glossary.h | 8 +-- doc/doxygen/headers/hp.h | 20 +++---- doc/doxygen/headers/main.h | 2 +- doc/doxygen/headers/matrixfree.h | 6 +- doc/doxygen/tutorial/tutorial.h.in | 4 +- examples/step-27/doc/intro.dox | 16 ++--- examples/step-27/doc/tooltip | 2 +- examples/step-27/step-27.cc | 2 +- examples/step-30/doc/intro.dox | 2 +- examples/step-46/doc/intro.dox | 6 +- .../deal.II/distributed/solution_transfer.h | 8 +-- include/deal.II/distributed/tria.h | 2 +- include/deal.II/dofs/dof_accessor.h | 60 +++++++++---------- include/deal.II/dofs/dof_handler.h | 20 +++---- include/deal.II/dofs/dof_objects.h | 16 ++--- include/deal.II/dofs/dof_tools.h | 4 +- include/deal.II/fe/fe.h | 22 +++---- include/deal.II/fe/fe_base.h | 8 +-- include/deal.II/fe/fe_bernstein.h | 4 +- include/deal.II/fe/fe_dgp.h | 4 +- include/deal.II/fe/fe_dgp_monomial.h | 4 +- include/deal.II/fe/fe_dgp_nonparametric.h | 4 +- include/deal.II/fe/fe_dgq.h | 4 +- include/deal.II/fe/fe_enriched.h | 8 +-- include/deal.II/fe/fe_face.h | 10 ++-- include/deal.II/fe/fe_nedelec.h | 6 +- include/deal.II/fe/fe_nothing.h | 2 +- include/deal.II/fe/fe_q_base.h | 6 +- include/deal.II/fe/fe_q_hierarchical.h | 6 +- include/deal.II/fe/fe_system.h | 4 +- include/deal.II/fe/fe_trace.h | 2 +- include/deal.II/fe/fe_values.h | 6 +- include/deal.II/grid/grid_tools.h | 2 +- include/deal.II/hp/dof_handler.h | 2 +- include/deal.II/hp/fe_collection.h | 6 +- include/deal.II/hp/fe_values.h | 20 +++---- include/deal.II/hp/refinement.h | 2 +- include/deal.II/lac/affine_constraints.h | 4 +- include/deal.II/matrix_free/dof_info.h | 14 ++--- include/deal.II/matrix_free/fe_evaluation.h | 8 +-- include/deal.II/matrix_free/mapping_info.h | 8 +-- .../matrix_free/mapping_info.templates.h | 6 +- include/deal.II/matrix_free/matrix_free.h | 36 +++++------ .../matrix_free/matrix_free.templates.h | 4 +- include/deal.II/matrix_free/task_info.h | 8 +-- .../multigrid/mg_transfer_global_coarsening.h | 4 +- include/deal.II/numerics/error_estimator.h | 16 ++--- .../numerics/error_estimator.templates.h | 6 +- include/deal.II/numerics/matrix_tools.h | 24 ++++---- include/deal.II/numerics/solution_transfer.h | 4 +- .../deal.II/numerics/vector_tools_boundary.h | 2 +- .../vector_tools_boundary.templates.h | 8 +-- .../numerics/vector_tools_interpolate.h | 2 +- include/deal.II/numerics/vector_tools_rhs.h | 6 +- source/dofs/dof_accessor_get.cc | 2 +- source/dofs/dof_handler.cc | 4 +- source/dofs/dof_handler_policy.cc | 36 +++++------ source/dofs/dof_objects.cc | 2 +- source/dofs/dof_renumbering.inst.in | 4 +- source/dofs/dof_tools_constraints.cc | 28 ++++----- source/dofs/dof_tools_sparsity.cc | 8 +-- source/fe/fe_bernstein.cc | 2 +- source/fe/fe_face.cc | 4 +- source/fe/fe_nedelec.cc | 4 +- source/fe/fe_q_base.cc | 2 +- source/fe/fe_q_hierarchical.cc | 4 +- source/fe/fe_raviart_thomas_nodal.cc | 6 +- source/hp/refinement.cc | 18 +++--- source/matrix_free/task_info.cc | 4 +- source/numerics/data_out_stack.cc | 2 +- source/numerics/derivative_approximation.cc | 2 +- source/numerics/matrix_creator.inst.in | 14 ++--- source/numerics/solution_transfer.cc | 6 +- tests/aniso/hp_constraints_dgp_08.cc | 2 +- tests/aniso/hp_constraints_dgp_monomial_08.cc | 2 +- .../hp_constraints_dgp_nonparametric_08.cc | 2 +- tests/aniso/hp_constraints_dgq_08.cc | 2 +- tests/bits/count_dofs_per_component_hp_01.cc | 2 +- tests/bits/count_dofs_per_component_hp_02.cc | 2 +- tests/bits/face_orientation_crash.cc | 2 +- .../bits/map_dofs_to_support_points_hp_01.cc | 2 +- .../bits/map_dofs_to_support_points_hp_02.cc | 2 +- tests/bits/point_gradient_hp_01.cc | 2 +- tests/bits/point_value_hp_01.cc | 2 +- tests/fail/hp_constraints_q_08.cc | 2 +- tests/fail/hp_constraints_q_system_08.cc | 2 +- tests/fail/hp_constraints_q_system_x_08.cc | 2 +- tests/fail/hp_constraints_rt_01.cc | 2 +- tests/fail/hp_constraints_rt_02.cc | 2 +- tests/fail/hp_constraints_rt_03.cc | 2 +- tests/fail/hp_constraints_rt_04.cc | 2 +- tests/fail/hp_constraints_rt_05.cc | 2 +- tests/fail/hp_constraints_rt_06.cc | 2 +- tests/fail/vectors_boundary_rhs_hp_02.cc | 2 +- tests/fail/vectors_rhs_hp_02.cc | 2 +- tests/fe/fe_enriched_07.cc | 2 +- tests/fe/fe_enriched_08.cc | 4 +- tests/fe/fe_enriched_08a.cc | 2 +- tests/grid/mesh_3d_18.cc | 2 +- tests/grid/vertex_as_face_07.cc | 2 +- tests/hp/boundary_matrices.cc | 2 +- tests/hp/boundary_matrices_hp.cc | 2 +- tests/hp/compare_hp_vs_nonhp_01.cc | 2 +- tests/hp/crash_08.cc | 2 +- tests/hp/crash_09.cc | 2 +- tests/hp/crash_11.cc | 2 +- tests/hp/crash_12.cc | 2 +- tests/hp/crash_15.cc | 2 +- tests/hp/crash_21.cc | 2 +- tests/hp/dof_handler_number_cache.cc | 2 +- tests/hp/error_prediction_01.cc | 2 +- tests/hp/fe_nothing_11.cc | 2 +- tests/hp/fe_nothing_20.cc | 2 +- tests/hp/flux_sparsity.cc | 2 +- tests/hp/flux_sparsity_02.cc | 2 +- tests/hp/get_interpolated_dof_values_01.cc | 2 +- tests/hp/get_interpolated_dof_values_02.cc | 2 +- tests/hp/get_interpolated_dof_values_03.cc | 2 +- tests/hp/hp_coarsening.cc | 6 +- tests/hp/hp_constraints_b.cc | 2 +- tests/hp/hp_constraints_common.h | 2 +- tests/hp/hp_constraints_common_no_support.h | 2 +- tests/hp/hp_constraints_dgp.cc | 2 +- tests/hp/hp_constraints_dgp_monomial.cc | 2 +- tests/hp/hp_constraints_dgp_nonparametric.cc | 2 +- tests/hp/hp_constraints_dgq.cc | 2 +- .../hp/hp_constraints_neither_dominate_01.cc | 2 +- tests/hp/hp_constraints_q.cc | 2 +- tests/hp/hp_constraints_q_hierarchical.cc | 2 +- tests/hp/hp_constraints_q_system.cc | 2 +- tests/hp/hp_constraints_q_system_x.cc | 2 +- tests/hp/hp_constraints_rt_nodal.cc | 2 +- tests/hp/hp_hanging_nodes_01.cc | 2 +- tests/hp/laplace.h | 4 +- tests/hp/matrices.cc | 2 +- tests/hp/n_boundary_dofs.cc | 2 +- tests/hp/p_adaptivity_absolute_threshold.cc | 4 +- tests/hp/p_adaptivity_fixed_number.cc | 4 +- tests/hp/p_adaptivity_flags.cc | 4 +- tests/hp/p_adaptivity_reference.cc | 4 +- tests/hp/p_adaptivity_regularity.cc | 4 +- tests/hp/p_adaptivity_relative_threshold.cc | 4 +- .../hp/set_dof_values_by_interpolation_01.cc | 2 +- .../hp/set_dof_values_by_interpolation_02.cc | 2 +- .../hp/set_dof_values_by_interpolation_03.cc | 2 +- tests/hp/solution_transfer.cc | 4 +- tests/hp/solution_transfer.output | 12 ++-- tests/hp/solution_transfer_02.cc | 2 +- tests/hp/solution_transfer_12.cc | 2 +- tests/hp/solution_transfer_12.output | 6 +- tests/hp/vectors_boundary_rhs_01.cc | 2 +- tests/hp/vectors_boundary_rhs_02.cc | 2 +- tests/hp/vectors_boundary_rhs_03.cc | 2 +- tests/hp/vectors_boundary_rhs_hp_01.cc | 2 +- tests/hp/vectors_boundary_rhs_hp_03.cc | 2 +- tests/hp/vectors_point_source_01.cc | 2 +- tests/hp/vectors_point_source_hp_01.cc | 2 +- tests/hp/vectors_rhs_01.cc | 2 +- tests/hp/vectors_rhs_02.cc | 2 +- tests/hp/vectors_rhs_03.cc | 2 +- tests/hp/vectors_rhs_hp_01.cc | 2 +- tests/hp/vectors_rhs_hp_03.cc | 2 +- tests/lac/inhomogeneous_constraints.cc | 2 +- tests/matrix_free/matrix_vector_hp.cc | 2 +- .../matrix_vector_hp_no_template.cc | 2 +- tests/matrix_free/thread_correctness_hp.cc | 2 +- tests/mpi/hp_step-4.cc | 2 +- tests/mpi/hp_unify_dof_indices_01.cc | 4 +- tests/mpi/hp_unify_dof_indices_02.cc | 4 +- tests/mpi/hp_unify_dof_indices_03.cc | 4 +- tests/mpi/hp_unify_dof_indices_04.cc | 4 +- tests/mpi/hp_unify_dof_indices_05.cc | 4 +- tests/mpi/hp_unify_dof_indices_06.cc | 4 +- tests/mpi/hp_unify_dof_indices_07.cc | 6 +- tests/mpi/hp_unify_dof_indices_08.cc | 4 +- tests/mpi/hp_unify_dof_indices_10.cc | 4 +- tests/mpi/hp_unify_dof_indices_11.cc | 4 +- tests/mpi/p_adaptivity_fixed_number.cc | 4 +- tests/mpi/trilinos_step-27.cc | 2 +- tests/vector_tools/boundaries_complex_hp.cc | 2 +- 181 files changed, 450 insertions(+), 454 deletions(-) diff --git a/doc/doxygen/headers/constraints.h b/doc/doxygen/headers/constraints.h index 6a1ad3a547..be19d57795 100644 --- a/doc/doxygen/headers/constraints.h +++ b/doc/doxygen/headers/constraints.h @@ -56,7 +56,7 @@ * are $x_{28}$ and $x_{40}$. Then, requiring that the finite element * function be continuous is equivalent to requiring that $x_{12}= * \frac 12 (x_{28}+x_{40})$. A similar situation occurs in the - * context of hp adaptive finite element methods. + * context of hp-adaptive finite element methods. * For example, when using Q1 and Q2 elements (i.e. using * FE_Q(1) and FE_Q(2)) on the two marked cells of the mesh * @image html hp-refinement-simple.png @@ -99,7 +99,7 @@ * This scheme of first building a linear system and then eliminating * constrained degrees of freedom is inefficient, and a bottleneck if there * are many constraints and matrices are full, i.e. especially for 3d and/or - * higher order or hp finite elements. Furthermore, it is impossible to + * higher order or hp-finite elements. Furthermore, it is impossible to * implement for %parallel computations where a process may not have access * to elements of the matrix. We therefore offer a second way of * building linear systems, using the @@ -204,8 +204,8 @@ * Condensation is an expensive operation, in particular if there * are many constraints and/or if the matrix has many nonzero entries. Both * is typically the case for 3d, or high polynomial degree computations, as - * well as for hp finite element methods, see for example the @ref hp_paper - * "hp paper". This is the case discussed in the hp tutorial program, @ref + * well as for hp-finite element methods, see for example the @ref hp_paper + * "hp-paper". This is the case discussed in the hp-tutorial program, @ref * step_27 "step-27", as well as in step-22 and @ref step_31 * "step-31". * diff --git a/doc/doxygen/headers/glossary.h b/doc/doxygen/headers/glossary.h index b2ab2452c7..e521674158 100644 --- a/doc/doxygen/headers/glossary.h +++ b/doc/doxygen/headers/glossary.h @@ -1136,12 +1136,12 @@ * * * - *
@anchor hp_paper %hp paper
- *
The "hp paper" is a paper by W. Bangerth and O. Kayser-Herold, titled + *
@anchor hp_paper %hp-paper
+ *
The "hp-paper" is a paper by W. Bangerth and O. Kayser-Herold, titled * "Data Structures and Requirements for hp Finite Element Software", that * describes many of the algorithms and data structures used in the implementation - * of the hp framework of deal.II. In particular, it summarizes many of the - * tricky points that have to be considered for %hp finite elements using continuous + * of the hp-framework of deal.II. In particular, it summarizes many of the + * tricky points that have to be considered for %hp-finite elements using continuous * elements. * * The full reference for this paper is as follows: diff --git a/doc/doxygen/headers/hp.h b/doc/doxygen/headers/hp.h index 7a18861b87..c3ff48e364 100644 --- a/doc/doxygen/headers/hp.h +++ b/doc/doxygen/headers/hp.h @@ -15,22 +15,22 @@ /** - * @defgroup hp hp finite element support + * @defgroup hp hp-finite element support * - * Classes and functions that have to do with hp finite elements. The step-27 + * Classes and functions that have to do with hp-finite elements. The step-27 * tutorial program gives an overview of how to use the classes in this * namespace. A slightly more exotic application is given in step-46. * - * The hp namespace implements the algorithms and data structures used for - * the hp framework in deal.II. An overview over the details of how these + * The hp-namespace implements the algorithms and data structures used for + * the hp-framework in deal.II. An overview over the details of how these * algorithms work and what data structures are used is given in the - * @ref hp_paper "hp paper". + * @ref hp_paper "hp-paper". */ /** - * @defgroup hpcollection hp Collections + * @defgroup hpcollection hp-Collections * - * In the implementation of the hp finite element method, each cell might have + * In the implementation of the hp-finite element method, each cell might have * a different finite element associated with it. To handle this, the * hp::DoFHandler must have a whole set of finite element classes associated * with it. This concept is represented by the hp::FECollection class: Objects @@ -82,14 +82,14 @@ * element object. This same observation also holds for the other collection * classes. * - * It is customary that within an hp finite element program, one keeps + * It is customary that within an hp-finite element program, one keeps * collections of finite elements and quadrature formulas with the same number * of elements, each element of the one collection matching the element in the * other. This is not necessary, but it often makes coding a lot simpler. If a * collection of mappings is used, the same holds for hp::MappingCollection * objects as well. * - * Whenever p adaptivity is considered in an hp finite element program, + * Whenever p-adaptivity is considered in an hp-finite element program, * a hierarchy of finite elements needs to be established to determine * succeeding finite elements for refinement and preceding ones for coarsening. * Typically, this hierarchy considers how finite element spaces are nested: @@ -109,7 +109,7 @@ /** - * A namespace for the implementation of hp finite element specific algorithms + * A namespace for the implementation of hp-finite element specific algorithms * and data structures. * * @ingroup hp diff --git a/doc/doxygen/headers/main.h b/doc/doxygen/headers/main.h index f95a6076b5..6042c842d6 100644 --- a/doc/doxygen/headers/main.h +++ b/doc/doxygen/headers/main.h @@ -201,7 +201,7 @@ * * The DoFHandler class and its associates are described in the @ref * dofs module. In addition, there are specialized versions that can - * handle multilevel and hp discretizations. These are described in + * handle multilevel and hp-discretizations. These are described in * the @ref mg and @ref hp modules. Finite element methods frequently * imply constraints on degrees of freedom, such as for hanging nodes * or nodes at which boundary conditions apply; dealing with such diff --git a/doc/doxygen/headers/matrixfree.h b/doc/doxygen/headers/matrixfree.h index 62cfc50677..98a5af2586 100644 --- a/doc/doxygen/headers/matrixfree.h +++ b/doc/doxygen/headers/matrixfree.h @@ -292,7 +292,7 @@ digraph G * array. The access granularity in terms of a cell index is controlled * by the auxiliary field internal::MatrixFreeFunctions::DoFInfo::row_starts * that is similar to the rowstart index in a compressed matrix storage. The - * scheme supports variable lengths because we support hp adaptivity and index + * scheme supports variable lengths because we support hp-adaptivity and index * indirections due to constraints that are contained in the main index * array. Due to vectorization over cells, the access granularity would * initially be in terms of cell batches. However, we must be able to @@ -318,7 +318,7 @@ digraph G * * * - *
  • Information to extract the FE index in hp adaptive computations.
    • + *
  • Information to extract the FE index in hp-adaptive computations.
    • *
  • Information about the 'first access' into a particular vector entry * that is used to zero out the entries in a destination vectors within the * MatrixFree::loop shortly before accessing them the first time. This is used @@ -408,7 +408,7 @@ digraph G * element. We use an auxiliary index array that points to the start of the * data for each cell, namely the `data_index_offsets` field for the * Jacobians, JxW values, and normal vectors, and `quadrature_point_offsets` - * for the quadrature points. This offset enables hp adaptivity with variable + * for the quadrature points. This offset enables hp-adaptivity with variable * lengths of fields similar to what is done for DoFInfo, but it also enables * something we call geometry compression. In order to reduce the data * access, we detect simple geometries of cells where Jacobians are constant diff --git a/doc/doxygen/tutorial/tutorial.h.in b/doc/doxygen/tutorial/tutorial.h.in index 0c88c63ba6..e74502dd43 100644 --- a/doc/doxygen/tutorial/tutorial.h.in +++ b/doc/doxygen/tutorial/tutorial.h.in @@ -325,7 +325,7 @@ * * * step-27 - * The hp finite element method. + * The hp-finite element method. *
    Keywords: hp::DoFHandler, hp::FECollection, hp::QCollection, * FESeries::Fourier, Triangulation::create_triangulation() * @@ -840,7 +840,7 @@ * * * - * hp finite elements + * hp-finite elements * * * step-27, diff --git a/examples/step-27/doc/intro.dox b/examples/step-27/doc/intro.dox index c28a7f1463..f591b60bee 100644 --- a/examples/step-27/doc/intro.dox +++ b/examples/step-27/doc/intro.dox @@ -60,7 +60,7 @@ deal.II, and that we will only have to provide the logic of what the program should do, not exactly how all this is going to happen. In deal.II, the $hp$ functionality is largely packaged into -the hp namespace. This namespace provides classes that handle +the hp-namespace. This namespace provides classes that handle $hp$ discretizations, assembling matrices and vectors, and other tasks. We will get to know many of them further down below. In addition, most of the functions in the DoFTools, and VectorTools @@ -71,7 +71,7 @@ module and the links found there. It may be worth giving a slightly larger perspective at the end of this first part of the introduction. $hp$ functionality has been implemented in a number of different finite element packages (see, for -example, the list of references cited in the @ref hp_paper "hp paper"). +example, the list of references cited in the @ref hp_paper "hp-paper"). However, by and large, most of these packages have implemented it only for the (i) the 2d case, and/or (ii) the discontinuous Galerkin method. The latter is a significant simplification because @@ -85,7 +85,7 @@ the resulting complexity. In particular, it handles computing the constraints (similar to hanging node constraints) of elements of different degree meeting at a face or edge. The many algorithmic and data structure techniques necessary for this are described in the -@ref hp_paper "hp paper" for those interested in such detail. +@ref hp_paper "hp-paper" for those interested in such detail. We hope that providing such a general implementation will help explore the potential of $hp$ methods further. @@ -177,7 +177,7 @@ the same time. -

    Assembling matrices and vectors with hp objects

    +

    Assembling matrices and vectors with hp-objects

    Following this, we have to set up matrices and vectors for the linear system of the correct size and assemble them. Setting them up works in exactly the @@ -250,7 +250,7 @@ usual fashion to assemble local contributions. -

    A simple indicator for hp refinement and estimating smoothness

    +

    A simple indicator for hp-refinement and estimating smoothness

    One of the central pieces of the adaptive finite element method is that we inspect the computed solution (a posteriori) with an indicator that tells us @@ -261,7 +261,7 @@ complicated strategies in some programs, most importantly in step-14. In any case, as long as the decision is only "refine this cell" or "do not refine this cell", the actual refinement step is not particularly -challenging. However, here we have a code that is capable of hp refinement, +challenging. However, here we have a code that is capable of hp-refinement, i.e. we suddenly have two choices whenever we detect that the error on a certain cell is too large for our liking: we can refine the cell by splitting it into several smaller ones, or we can increase the polynomial degree of the @@ -611,7 +611,7 @@ estimated smoothness exponent will be the same in either case. -

    Complications with linear systems for hp discretizations

    +

    Complications with linear systems for hp-discretizations

    Creating the sparsity pattern

    @@ -643,7 +643,7 @@ The early tutorial programs use first or second degree finite elements, so removing entries in the sparsity pattern corresponding to constrained degrees of freedom does not have a large impact on the overall number of zeros explicitly stored by the matrix. However, since as many as a third of the degrees of -freedom may be constrained in an hp discretization (and, with higher degree +freedom may be constrained in an hp-discretization (and, with higher degree elements, these constraints can couple one DoF to as many as ten or twenty other DoFs), it is worthwhile to take these constraints into consideration since the resulting matrix will be much sparser (and, therefore, matrix-vector products or diff --git a/examples/step-27/doc/tooltip b/examples/step-27/doc/tooltip index 0e992e22fd..4a56ec9039 100644 --- a/examples/step-27/doc/tooltip +++ b/examples/step-27/doc/tooltip @@ -1 +1 @@ -Using the hp finite element method for an elliptic problem. +Using the hp-finite element method for an elliptic problem. diff --git a/examples/step-27/step-27.cc b/examples/step-27/step-27.cc index f01c7d8e53..fb5664b89c 100644 --- a/examples/step-27/step-27.cc +++ b/examples/step-27/step-27.cc @@ -257,7 +257,7 @@ namespace Step27 // This function is again a verbatim copy of what we already did in // step-6. Despite function calls with exactly the same names and arguments, // the algorithms used internally are different in some aspect since the - // dof_handler variable here is an hp object. + // dof_handler variable here is an hp-object. template void LaplaceProblem::setup_system() { diff --git a/examples/step-30/doc/intro.dox b/examples/step-30/doc/intro.dox index d2fd5587f3..20733dbcc0 100644 --- a/examples/step-30/doc/intro.dox +++ b/examples/step-30/doc/intro.dox @@ -428,7 +428,7 @@ steps: requested refinement, using the requested isotropic and anisotropic flags. This approach is similar to the one we have used in step-27 -for hp refinement and +for hp-refinement and has the great advantage of flexibility: Any error indicator can be used in the anisotropic process, i.e. if you have quite involved a posteriori goal-oriented error indicators available you can use them as easily as a simple diff --git a/examples/step-46/doc/intro.dox b/examples/step-46/doc/intro.dox index ce6e9af3b8..9193ff397a 100644 --- a/examples/step-46/doc/intro.dox +++ b/examples/step-46/doc/intro.dox @@ -248,7 +248,7 @@ the two elements are just variations of each other in that they have the same number of vector components but have different polynomial degrees — this smells very much like what one would do in $hp$ finite element methods, and it is exactly what we are going to do here: we are going to (ab)use the classes -and facilities of the hp namespace to assign different elements to different +and facilities of the hp-namespace to assign different elements to different cells. In other words, we will use collect the two finite elements in an hp::FECollection, will integrate with an appropriate hp::QCollection using an hp::FEValues object, and our DoFHandler will be in hp-mode. You @@ -256,7 +256,7 @@ may wish to take a look at step-27 for an overview of all of these concepts. Before going on describing the testcase, let us clarify a bit why this approach of extending the functions by zero to the entire domain and then -mapping the problem on to the hp framework makes sense: +mapping the problem on to the hp-framework makes sense: - It makes things uniform: On all cells, the number of vector components is the same (here, 2*dim+1). This makes all sorts of @@ -583,7 +583,7 @@ cell is on. Secondly, we use an object of type DoFHandler operating in hp-mode. This class needs to know which cells will use the Stokes and which the elasticity finite element. At the beginning of each refinement cycle we will therefore -have to walk over all cells and set the (in hp parlance) active FE index to +have to walk over all cells and set the (in hp-parlance) active FE index to whatever is appropriate in the current situation. While we can use symbolic names for the material id, the active FE index is in fact a number that will frequently be used to index into collections of objects (e.g. of type diff --git a/include/deal.II/distributed/solution_transfer.h b/include/deal.II/distributed/solution_transfer.h index f0d11ac987..f8b7082aac 100644 --- a/include/deal.II/distributed/solution_transfer.h +++ b/include/deal.II/distributed/solution_transfer.h @@ -153,9 +153,9 @@ namespace parallel * @endcode * * - *

    Note on usage with DoFHandler with hp capabilities

    + *

    Note on usage with DoFHandler with hp-capabilities

    * - * Since data on DoFHandler objects with hp capabilities is associated with + * Since data on DoFHandler objects with hp-capabilities is associated with * many different FiniteElement objects, each cell's data has to be * processed with its corresponding `future_fe_index`. Further, if * refinement is involved, data will be packed on the parent cell with its @@ -166,11 +166,11 @@ namespace parallel * hp::FECollection::find_dominated_fe_extended() for more information). * * Transferring a solution across refinement works exactly like in the - * non-hp case. However, when considering serialization, we also have to + * non-hp-case. However, when considering serialization, we also have to * store the active_fe_indices in an additional step. A code snippet * demonstrating serialization with the * parallel::distributed::SolutionTransfer class with DoFHandler objects - * with hp capabilities is provided in the following. Here VectorType is + * with hp-capabilities is provided in the following. Here VectorType is * your favorite vector type, e.g. PETScWrappers::MPI::Vector, * TrilinosWrappers::MPI::Vector, or corresponding block vectors. * diff --git a/include/deal.II/distributed/tria.h b/include/deal.II/distributed/tria.h index 9d3e465a09..6189a6169a 100644 --- a/include/deal.II/distributed/tria.h +++ b/include/deal.II/distributed/tria.h @@ -487,7 +487,7 @@ namespace parallel * assembly and solving. In practice, determining this cost is of course * not trivial since we don't solve on isolated cells, but on the entire * mesh. In such cases, one could, for example, choose the weight equal - * to the number of unknowns per cell (in the context of hp finite + * to the number of unknowns per cell (in the context of hp-finite * element methods), or using a heuristic that estimates the cost on * each cell depending on whether, for example, one has to run some * expensive algorithm on some cells but not others (such as forming diff --git a/include/deal.II/dofs/dof_accessor.h b/include/deal.II/dofs/dof_accessor.h index e32702a48e..bea7a6188b 100644 --- a/include/deal.II/dofs/dof_accessor.h +++ b/include/deal.II/dofs/dof_accessor.h @@ -399,7 +399,7 @@ public: * ::DoFHandler class, this value must be equal to its default value since * that class only supports the same finite element on all cells anyway. * - * However, when the relevant DoFHandler object has hp capabilities enabled, + * However, when the relevant DoFHandler object has hp-capabilities enabled, * different finite element objects may be used on different cells. On faces * between two cells, as well as vertices, there may therefore be two sets * of degrees of freedom, one for each of the finite elements used on the @@ -449,7 +449,7 @@ public: * ::DoFHandler class, this value must be equal to its default value since * that class only supports the same finite element on all cells anyway. * - * However, when hp capabilities are enabled, different finite element + * However, when hp-capabilities are enabled, different finite element * objects may be used on different cells. On faces between two cells, as * well as vertices, there may therefore be two sets of degrees of freedom, * one for each of the finite elements used on the adjacent cells. In order @@ -483,7 +483,7 @@ public: * ::DoFHandler class, this value must be equal to its default value since * that class only supports the same finite element on all cells anyway. * - * However, when hp capabilities are enabled, different finite element + * However, when hp-capabilities are enabled, different finite element * objects may be used on different cells. On faces between two cells, as * well as vertices, there may therefore be two sets of degrees of freedom, * one for each of the finite elements used on the adjacent cells. In order @@ -528,8 +528,8 @@ public: /** * Return the number of finite elements that are active on a given object. * - * When hp capabilities are disabled the answer is, of course, always one. - * However, when hp capabilities are enabled, this isn't the case: If this + * When hp-capabilities are disabled the answer is, of course, always one. + * However, when hp-capabilities are enabled, this isn't the case: If this * is a cell, the answer is of course one. If it is a face, the answer may * be one or two, depending on whether the two adjacent cells use the same * finite element or not. If it is an edge in 3d, the possible return value @@ -540,8 +540,8 @@ public: /** * Return the @p n-th active fe index on this object. For cells and all non- - * hp objects, there is only a single active fe index, so the argument must - * be equal to zero. For lower-dimensional hp objects, there are + * hp-objects, there is only a single active fe index, so the argument must + * be equal to zero. For lower-dimensional hp-objects, there are * n_active_fe_indices() active finite elements, and this function can be * queried for their indices. */ @@ -559,7 +559,7 @@ public: /** * Return true if the finite element with given index is active on the - * present object. When the current DoFHandler does not have hp + * present object. When the current DoFHandler does not have hp- * capabilities, this is of course the case only if @p fe_index equals * zero. For cells, it is the case if @p fe_index equals active_fe_index() * of this cell. For faces and other lower- dimensional objects, there may @@ -670,7 +670,7 @@ protected: * ::DoFHandler class, this value must be equal to its default value since * that class only supports the same finite element on all cells anyway. * - * However, when the relevant DoFHandler has hp capabilities, different + * However, when the relevant DoFHandler has hp-capabilities, different * finite element objects may be used on different cells. On faces between * two cells, as well as vertices, there may therefore be two sets of * degrees of freedom, one for each of the finite elements used on the @@ -699,7 +699,7 @@ protected: * ::DoFHandler class, this value must be equal to its default value since * that class only supports the same finite element on all cells anyway. * - * However, when the relevant DoFHandler has hp capabilities, different + * However, when the relevant DoFHandler has hp-capabilities, different * finite element objects may be used on different cells. On faces between * two cells, as well as vertices, there may therefore be two sets of * degrees of freedom, one for each of the finite elements used on the @@ -947,7 +947,7 @@ public: * ::DoFHandler class, this value must be equal to its default value since * that class only supports the same finite element on all cells anyway. * - * However, when the relevant DoFHandler has hp capabilities, different + * However, when the relevant DoFHandler has hp-capabilities, different * finite element objects may be used on different cells. On faces between * two cells, as well as vertices, there may therefore be two sets of * degrees of freedom, one for each of the finite elements used on the @@ -988,7 +988,7 @@ public: * ::DoFHandler class, this value must be equal to its default value since * that class only supports the same finite element on all cells anyway. * - * However, when the relevant DoFHandler has hp capabilities, different + * However, when the relevant DoFHandler has hp-capabilities, different * finite element objects may be used on different cells. On faces between * two cells, as well as vertices, there may therefore be two sets of * degrees of freedom, one for each of the finite elements used on the @@ -1011,7 +1011,7 @@ public: * ::DoFHandler class, this value must be equal to its default value since * that class only supports the same finite element on all cells anyway. * - * However, when the relevant DoFHandler has hp capabilities, different + * However, when the relevant DoFHandler has hp-capabilities, different * finite element objects may be used on different cells. On faces between * two cells, as well as vertices, there may therefore be two sets of * degrees of freedom, one for each of the finite elements used on the @@ -1155,7 +1155,7 @@ protected: * ::DoFHandler class, this value must be equal to its default value since * that class only supports the same finite element on all cells anyway. * - * However, when the relevant DoFHandler has hp capabilities, different + * However, when the relevant DoFHandler has hp-capabilities, different * finite element objects may be used on different cells. On faces between * two cells, as well as vertices, there may therefore be two sets of * degrees of freedom, one for each of the finite elements used on the @@ -1179,7 +1179,7 @@ protected: * ::DoFHandler class, this value must be equal to its default value since * that class only supports the same finite element on all cells anyway. * - * However, when the relevant DoFHandler has hp capabilities, different + * However, when the relevant DoFHandler has hp-capabilities, different * finite element objects may be used on different cells. On faces between * two cells, as well as vertices, there may therefore be two sets of * degrees of freedom, one for each of the finite elements used on the @@ -1632,11 +1632,11 @@ public: * we use the restriction matrices provided by the finite element class to * compute the interpolation from the children to the present cell. * - * If the cell is part of a DoFHandler with hp capabilities, cells only have + * If the cell is part of a DoFHandler with hp-capabilities, cells only have * an associated finite element space if they are active. However, this * function is supposed to also provide information on inactive cells with * children. Consequently, it carries a third argument that can be used in - * the hp context that denotes the finite element space we are supposed to + * the hp-context that denotes the finite element space we are supposed to * interpolate onto. If the cell is active, this function then obtains the * finite element function from the values vector on this cell * and interpolates it onto the space described by the @@ -1685,10 +1685,10 @@ public: * the children of this cell. These requirements are not taken care of and * must be enforced by the user afterward. * - * If the cell is part of a DoFHandler with hp capabilities, cells only have + * If the cell is part of a DoFHandler with hp-capabilities, cells only have * an associated finite element space if they are active. However, this * function is supposed to also work on inactive cells with children. - * Consequently, it carries a third argument that can be used in the hp + * Consequently, it carries a third argument that can be used in the hp- * context that denotes the finite element space we are supposed to * interpret the input vector of this function in. If the cell is active, * this function then interpolates the input vector interpreted as an @@ -1890,12 +1890,12 @@ public: /** * Return the finite element that is used on the cell pointed to by this - * iterator. For DoFHandler objects without hp capabilities, this is of + * iterator. For DoFHandler objects without hp-capabilities, this is of * course always the same element, independent of the cell we are presently - * on, but for hp DoFHandler objects this may change from cell to cell. + * on, but for hp-DoFHandler objects this may change from cell to cell. * * @note Since degrees of freedom only exist on active cells for DoFHandler - * objects with hp capabilities (i.e., there is currently no implementation + * objects with hp-capabilities (i.e., there is currently no implementation * of multilevel such objects), it does not make sense to query the finite * element on non-active cells since they do not have finite element spaces * associated with them without having any degrees of freedom. Consequently, @@ -1907,10 +1907,10 @@ public: /** * Return the index inside the hp::FECollection of the FiniteElement used * for this cell. This function is only useful if the DoFHandler object - * associated with the current cell has hp capabilities enabled. + * associated with the current cell has hp-capabilities enabled. * * @note Since degrees of freedom only exist on active cells for DoFHandler - * objects with hp capabilities (i.e., there is currently no implementation + * objects with hp-capabilities (i.e., there is currently no implementation * of multilevel such objects), it does not make sense to query the finite * element on non-active cells since they do not have finite element spaces * associated with them without having any degrees of freedom. Consequently, @@ -1935,11 +1935,11 @@ public: /** * Set the index of the FiniteElement used for this cell. This determines * which element in an hp::FECollection to use. This function is only useful - * if the DoF handler object associated with the current cell has hp + * if the DoF handler object associated with the current cell has hp- * capabilities enabled. * * @note Since degrees of freedom only exist on active cells for DoFHandler - * objects with hp capabilities (i.e., there is currently no implementation + * objects with hp-capabilities (i.e., there is currently no implementation * of multilevel such objects), it does not make sense to query the finite * element on non-active cells since they do not have finite element spaces * associated with them without having any degrees of freedom. Consequently, @@ -1997,12 +1997,12 @@ public: * active one will remain unchanged, in which case the active finite element * will be returned. * - * For DoFHandlers without hp capabilities enabled, this is of course always - * the same element, independent of the cell we are presently on, but for hp + * For DoFHandlers without hp-capabilities enabled, this is of course always + * the same element, independent of the cell we are presently on, but for hp- * DoFHandler objects this may change from cell to cell. * * @note Since degrees of freedom only exist on active cells for DoFHandler - * objects with hp capabilities (i.e., there is currently no implementation + * objects with hp-capabilities (i.e., there is currently no implementation * of multilevel such objects), it does not make sense to query the finite * element on non-active cells since they do not have finite element spaces * associated with them without having any degrees of freedom. Consequently, @@ -2019,7 +2019,7 @@ public: * which case the fe_index of the active finite element will be returned. * * @note Since degrees of freedom only exist on active cells for DoFHandler - * objects with hp capabilities (i.e., there is currently no implementation + * objects with hp-capabilities (i.e., there is currently no implementation * of multilevel such objects), it does not make sense to query the finite * element on non-active cells since they do not have finite element spaces * associated with them without having any degrees of freedom. Consequently, diff --git a/include/deal.II/dofs/dof_handler.h b/include/deal.II/dofs/dof_handler.h index 363b3f7eaf..a2291ac533 100644 --- a/include/deal.II/dofs/dof_handler.h +++ b/include/deal.II/dofs/dof_handler.h @@ -233,7 +233,7 @@ namespace parallel * The whole process of working with objects of this type is explained in * step-27. Many of the algorithms this class implements are described in * the - * @ref hp_paper "hp paper". + * @ref hp_paper "hp-paper". * * *

    Active FE indices and their behavior under mesh refinement

    @@ -702,7 +702,7 @@ public: distribute_mg_dofs(); /** - * Returns whether this DoFHandler has hp capabilities. + * Returns whether this DoFHandler has hp-capabilities. */ bool has_hp_capabilities() const; @@ -1382,19 +1382,19 @@ public: /** * Exception used when a certain feature doesn't make sense when - * DoFHandler does not hp capabilities. + * DoFHandler does not hp-capabilities. */ DeclExceptionMsg(ExcNotAvailableWithoutHP, "The current function doesn't make sense when used with a " - "DoFHandler without hp capabilities."); + "DoFHandler without hp-capabilities."); /** * Exception used when a certain feature is not implemented when the - * DoFHandler has hp capabilities. + * DoFHandler has hp-capabilities. */ DeclExceptionMsg(ExcNotImplementedWithHP, "The current function has not yet been implemented for a " - "DoFHandler with hp capabilities."); + "DoFHandler with hp-capabilities."); private: /** @@ -1525,7 +1525,7 @@ private: BlockInfo block_info_object; /** - * Boolean indicating whether or not the current DoFHandler has hp + * Boolean indicating whether or not the current DoFHandler has hp- * capabilities. */ bool hp_capability_enabled; @@ -1593,7 +1593,7 @@ private: * relevant active finite elements. * * @note In normal mode it is possible to access this data strucutre directly. - * In hp mode, an indirection via hp_object_fe_indices/hp_object_fe_ptr is + * In hp-mode, an indirection via hp_object_fe_indices/hp_object_fe_ptr is * necessary. */ mutable std::vector, dim + 1>> @@ -1614,14 +1614,14 @@ private: /** * Active fe index of an active cell (identified by level and level index). - * This vector is only used in hp mode. + * This vector is only used in hp-mode. */ mutable std::vector> hp_cell_active_fe_indices; /** * Future fe index of an active cell (identified by level and level index). - * This vector is only used in hp mode. + * This vector is only used in hp-mode. */ mutable std::vector> hp_cell_future_fe_indices; diff --git a/include/deal.II/dofs/dof_objects.h b/include/deal.II/dofs/dof_objects.h index e641d7324a..2546dd7d7b 100644 --- a/include/deal.II/dofs/dof_objects.h +++ b/include/deal.II/dofs/dof_objects.h @@ -84,9 +84,9 @@ namespace internal * * The third argument, @p fe_index, must equal zero. It is otherwise * unused, but we retain the argument so that we can use the same - * interface for non-hp and hp finite element methods, in effect making - * it possible to share the DoFAccessor class hierarchy between hp and - * non-hp classes. + * interface for non-hp- and hp-finite element methods, in effect making + * it possible to share the DoFAccessor class hierarchy between hp- and + * non-hp-classes. */ template void @@ -104,9 +104,9 @@ namespace internal * * The third argument, @p fe_index, must equal zero. It is otherwise * unused, but we retain the argument so that we can use the same - * interface for non-hp and hp finite element methods, in effect making - * it possible to share the DoFAccessor class hierarchy between hp and - * non-hp classes. + * interface for non-hp- and hp-finite element methods, in effect making + * it possible to share the DoFAccessor class hierarchy between hp- and + * non-hp-classes. */ template types::global_dof_index @@ -187,7 +187,7 @@ namespace internal Assert((fe_index == dealii::DoFHandler::default_fe_index), ExcMessage("Only zero fe_index values are allowed for " - "non-hp DoFHandlers.")); + "non-hp-DoFHandlers.")); return true; } @@ -206,7 +206,7 @@ namespace internal Assert( (fe_index == dealii::DoFHandler::default_fe_index), ExcMessage( - "Only the default FE index is allowed for non-hp DoFHandler objects")); + "Only the default FE index is allowed for non-hp-DoFHandler objects")); Assert( local_index < dof_handler.get_fe().template n_dofs_per_object(), ExcIndexRange(local_index, diff --git a/include/deal.II/dofs/dof_tools.h b/include/deal.II/dofs/dof_tools.h index 194b49d005..5e4926f822 100644 --- a/include/deal.II/dofs/dof_tools.h +++ b/include/deal.II/dofs/dof_tools.h @@ -2337,7 +2337,7 @@ namespace DoFTools const ComponentMask &mask = ComponentMask()); /** - * Same as the previous function but for the hp case. + * Same as the previous function but for the hp-case. */ template void @@ -2386,7 +2386,7 @@ namespace DoFTools const ComponentMask & mask = ComponentMask()); /** - * Same as the previous function but for the hp case. + * Same as the previous function but for the hp-case. */ template void diff --git a/include/deal.II/fe/fe.h b/include/deal.II/fe/fe.h index d0e58d067c..13c4a0b16a 100644 --- a/include/deal.II/fe/fe.h +++ b/include/deal.II/fe/fe.h @@ -113,7 +113,7 @@ class FESystem; * particular feature is implemented. An example is whether an element * implements the information necessary to use it in the $hp$ finite element * context (see - * @ref hp "hp finite element support"). + * @ref hp "hp-finite element support"). * * *

    Nomenclature

    @@ -339,7 +339,7 @@ class FESystem; * neighboring (but differently refined) cells. The case that the finite * element spaces on different sides of a face are different, i.e., the $hp$ * case (see - * @ref hp "hp finite element support") + * @ref hp "hp-finite element support") * is handled by separate functions. See the * FiniteElement::get_face_interpolation_matrix() and * FiniteElement::get_subface_interpolation_matrix() functions. @@ -820,7 +820,7 @@ public: /** * This operator returns a reference to the present object if the argument * given equals to zero. While this does not seem particularly useful, it is - * helpful in writing code that works with both ::DoFHandler and the hp + * helpful in writing code that works with both ::DoFHandler and the hp- * version hp::DoFHandler, since one can then write code like this: * @code * dofs_per_cell = @@ -833,7 +833,7 @@ public: * doesn't offer a dofs_per_cell member variable: one first has * to select which finite element to work on, which is done using the * operator[]. Fortunately, cell-@>active_fe_index() also works - * for non-hp classes and simply returns zero in that case. The present + * for non-hp-classes and simply returns zero in that case. The present * operator[] accepts this zero argument, by returning the finite element * with index zero within its collection (that, of course, consists only of * the present finite element anyway). @@ -1230,7 +1230,7 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". That + * the new way, which has to be used to make elements "hp-compatible". That * means, the element properly implements the get_face_interpolation_matrix * and get_subface_interpolation_matrix methods. Therefore the return value * also indicates whether a call to the get_face_interpolation_matrix() @@ -1239,14 +1239,14 @@ public: * * Currently the main purpose of this function is to allow the * make_hanging_node_constraints method to decide whether the new - * procedures, which are supposed to work in the hp framework can be used, - * or if the old well verified but not hp capable functions should be used. + * procedures, which are supposed to work in the hp-framework can be used, + * or if the old well verified but not hp-capable functions should be used. * Once the transition to the new scheme for computing the interface * constraints is complete, this function will be superfluous and will * probably go away. * * Derived classes should implement this function accordingly. The default - * assumption is that a finite element does not provide hp capable face + * assumption is that a finite element does not provide hp-capable face * interpolation, and the default implementation therefore returns @p false. */ virtual bool @@ -1312,12 +1312,12 @@ public: /** - * @name Functions to support hp + * @name Functions to support hp- * @{ */ /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. @@ -1362,7 +1362,7 @@ public: * * For a definition of domination, see FiniteElementDomination::Domination * and in particular the - * @ref hp_paper "hp paper". + * @ref hp_paper "hp-paper". */ virtual FiniteElementDomination::Domination compare_for_domination(const FiniteElement &fe_other, diff --git a/include/deal.II/fe/fe_base.h b/include/deal.II/fe/fe_base.h index 6a446b64e3..ac3deeac3e 100644 --- a/include/deal.II/fe/fe_base.h +++ b/include/deal.II/fe/fe_base.h @@ -46,9 +46,9 @@ namespace FiniteElementDomination * Q(k') if $k\le k'$. * * This enum is used in the FiniteElement::compare_for_domination() function - * that is used in the context of hp finite element methods when determining + * that is used in the context of hp-finite element methods when determining * what to do at faces where two different finite elements meet (see the - * @ref hp_paper "hp paper" + * @ref hp_paper "hp-paper" * for a more detailed description of the following). In that case, the * degrees of freedom of one side need to be constrained to those on the * other side. The determination which side is which is based on the outcome @@ -56,7 +56,7 @@ namespace FiniteElementDomination * to the dominating one. * * Note that there are situations where neither side dominates. The - * @ref hp_paper "hp paper" + * @ref hp_paper "hp-paper" * lists two case, with the simpler one being that a $Q_2\times Q_1$ vector- * valued element (i.e. a FESystem(FE_Q(2),1,FE_Q(1),1)) meets * a $Q_1\times Q_2$ element: here, for each of the two vector-components, @@ -80,7 +80,7 @@ namespace FiniteElementDomination * could also be used by discontinuous elements, for example. * * More details on domination can be found in the - * @ref hp_paper "hp paper". + * @ref hp_paper "hp-paper". */ enum Domination { diff --git a/include/deal.II/fe/fe_bernstein.h b/include/deal.II/fe/fe_bernstein.h index c8fabd805a..b734bc5d66 100644 --- a/include/deal.II/fe/fe_bernstein.h +++ b/include/deal.II/fe/fe_bernstein.h @@ -138,13 +138,13 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". */ virtual bool hp_constraints_are_implemented() const override; /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. diff --git a/include/deal.II/fe/fe_dgp.h b/include/deal.II/fe/fe_dgp.h index caa3b23916..cb3b10959b 100644 --- a/include/deal.II/fe/fe_dgp.h +++ b/include/deal.II/fe/fe_dgp.h @@ -328,7 +328,7 @@ public: */ /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. @@ -373,7 +373,7 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". * * For the FE_DGP class the result is always true (independent of the degree * of the element), as it has no hanging nodes (being a discontinuous diff --git a/include/deal.II/fe/fe_dgp_monomial.h b/include/deal.II/fe/fe_dgp_monomial.h index ddbc679d31..4fb8092692 100644 --- a/include/deal.II/fe/fe_dgp_monomial.h +++ b/include/deal.II/fe/fe_dgp_monomial.h @@ -303,7 +303,7 @@ public: */ /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. @@ -346,7 +346,7 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". * * For the FE_DGPMonomial class the result is always true (independent of * the degree of the element), as it has no hanging nodes (being a diff --git a/include/deal.II/fe/fe_dgp_nonparametric.h b/include/deal.II/fe/fe_dgp_nonparametric.h index 4944c55abc..13ab9c0231 100644 --- a/include/deal.II/fe/fe_dgp_nonparametric.h +++ b/include/deal.II/fe/fe_dgp_nonparametric.h @@ -420,7 +420,7 @@ public: */ /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. @@ -465,7 +465,7 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". * * For the FE_DGPNonparametric class the result is always true (independent * of the degree of the element), as it has no hanging nodes (being a diff --git a/include/deal.II/fe/fe_dgq.h b/include/deal.II/fe/fe_dgq.h index 7e5828a6a3..90c51890e5 100644 --- a/include/deal.II/fe/fe_dgq.h +++ b/include/deal.II/fe/fe_dgq.h @@ -229,7 +229,7 @@ public: */ /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. @@ -274,7 +274,7 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". * * For the FE_DGQ class the result is always true (independent of the degree * of the element), as it has no hanging nodes (being a discontinuous diff --git a/include/deal.II/fe/fe_enriched.h b/include/deal.II/fe/fe_enriched.h index 8214860273..3747fcc680 100644 --- a/include/deal.II/fe/fe_enriched.h +++ b/include/deal.II/fe/fe_enriched.h @@ -118,7 +118,7 @@ DEAL_II_NAMESPACE_OPEN * * In most applications it is beneficial to introduce enrichments only in * some part of the domain (e.g. around a crack tip) and use standard FE (e.g. - * FE_Q) elsewhere. This can be achieved by using the hp finite element + * FE_Q) elsewhere. This can be achieved by using the hp-finite element * framework in deal.II that allows for the use of different elements on * different cells. To make the resulting space $C^0$ continuous, it is then * necessary for the DoFHandler class and @@ -194,7 +194,7 @@ public: * element within a DoFHandler with hp-capabilities. * * See the discussion in the class documentation on how to use this element - * in the context of hp finite element methods. + * in the context of hp-finite element methods. */ FE_Enriched(const FiniteElement &fe_base); @@ -336,7 +336,7 @@ public: */ /** - * Return whether this element implements hp constraints. + * Return whether this element implements hp-constraints. * * This function returns @p true if and only if all its base elements return @p true * for this function. @@ -381,7 +381,7 @@ public: const unsigned int face_no = 0) const override; /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. diff --git a/include/deal.II/fe/fe_face.h b/include/deal.II/fe/fe_face.h index 6faad3c65d..6091ee0132 100644 --- a/include/deal.II/fe/fe_face.h +++ b/include/deal.II/fe/fe_face.h @@ -128,7 +128,7 @@ public: */ /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. @@ -170,7 +170,7 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". */ virtual bool hp_constraints_are_implemented() const override; @@ -275,13 +275,13 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". */ virtual bool hp_constraints_are_implemented() const override; /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. @@ -527,7 +527,7 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". */ virtual bool hp_constraints_are_implemented() const override; diff --git a/include/deal.II/fe/fe_nedelec.h b/include/deal.II/fe/fe_nedelec.h index 7e3376700c..621b544f22 100644 --- a/include/deal.II/fe/fe_nedelec.h +++ b/include/deal.II/fe/fe_nedelec.h @@ -177,11 +177,11 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". * * For the FE_Nedelec class the result is always true (independent * of the degree of the element), as it implements the complete set of - * functions necessary for hp capability. + * functions necessary for hp-capability. */ virtual bool hp_constraints_are_implemented() const override; @@ -194,7 +194,7 @@ public: const unsigned int codim = 0) const override final; /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. diff --git a/include/deal.II/fe/fe_nothing.h b/include/deal.II/fe/fe_nothing.h index 4660237f35..089e3c33cb 100644 --- a/include/deal.II/fe/fe_nothing.h +++ b/include/deal.II/fe/fe_nothing.h @@ -30,7 +30,7 @@ DEAL_II_NAMESPACE_OPEN * Definition of a finite element space with zero degrees of freedom and that, * consequently, can only represent a single function: the zero function. * - * This class is useful (in the context of an hp method) to represent empty + * This class is useful (in the context of an hp-method) to represent empty * cells in the triangulation on which no degrees of freedom should be * allocated, or to describe a field that is extended by zero to a part of the * domain where we don't need it. Thus a triangulation may be divided into two diff --git a/include/deal.II/fe/fe_q_base.h b/include/deal.II/fe/fe_q_base.h index ae2a6cffc3..1340d25ad4 100644 --- a/include/deal.II/fe/fe_q_base.h +++ b/include/deal.II/fe/fe_q_base.h @@ -218,17 +218,17 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". * * For the FE_Q class the result is always true (independent of the degree * of the element), as it implements the complete set of functions necessary - * for hp capability. + * for hp-capability. */ virtual bool hp_constraints_are_implemented() const override; /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. diff --git a/include/deal.II/fe/fe_q_hierarchical.h b/include/deal.II/fe/fe_q_hierarchical.h index 47d97564b9..d133672cf0 100644 --- a/include/deal.II/fe/fe_q_hierarchical.h +++ b/include/deal.II/fe/fe_q_hierarchical.h @@ -570,11 +570,11 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". * * For the FE_Q_Hierarchical class the result is always true (independent of * the degree of the element), as it implements the complete set of - * functions necessary for hp capability. + * functions necessary for hp-capability. */ virtual bool hp_constraints_are_implemented() const override; @@ -597,7 +597,7 @@ public: RefinementCase::isotropic_refinement) const override; /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. diff --git a/include/deal.II/fe/fe_system.h b/include/deal.II/fe/fe_system.h index 709c6649ae..d085c62380 100644 --- a/include/deal.II/fe/fe_system.h +++ b/include/deal.II/fe/fe_system.h @@ -932,7 +932,7 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". * * This function returns @p true if and only if all its base elements return * @p true for this function. @@ -978,7 +978,7 @@ public: const unsigned int face_no = 0) const override; /** - * If, on a vertex, several finite elements are active, the hp code first + * If, on a vertex, several finite elements are active, the hp-code first * assigns the degrees of freedom of each of these FEs different global * indices. It then calls this function to find out which of them should get * identical values, and consequently can receive the same global DoF index. diff --git a/include/deal.II/fe/fe_trace.h b/include/deal.II/fe/fe_trace.h index 28c61e2b71..2b640ba437 100644 --- a/include/deal.II/fe/fe_trace.h +++ b/include/deal.II/fe/fe_trace.h @@ -94,7 +94,7 @@ public: /** * Return whether this element implements its hanging node constraints in - * the new way, which has to be used to make elements "hp compatible". + * the new way, which has to be used to make elements "hp-compatible". */ virtual bool hp_constraints_are_implemented() const override; diff --git a/include/deal.II/fe/fe_values.h b/include/deal.II/fe/fe_values.h index 0972902873..e5c92c79ab 100644 --- a/include/deal.II/fe/fe_values.h +++ b/include/deal.II/fe/fe_values.h @@ -3800,7 +3800,7 @@ public: * * Though it seems that it is not very useful, this function is there to * provide capability to the hp::FEValues class, in which case it provides - * the FEValues object for the present cell (remember that for hp finite + * the FEValues object for the present cell (remember that for hp-finite * elements, the actual FE object used may change from cell to cell, so we * also need different FEValues objects for different cells; once you * reinitialize the hp::FEValues object for a specific cell, it retrieves @@ -4039,7 +4039,7 @@ public: * * Though it seems that it is not very useful, this function is there to * provide capability to the hp::FEValues class, in which case it provides - * the FEValues object for the present cell (remember that for hp finite + * the FEValues object for the present cell (remember that for hp-finite * elements, the actual FE object used may change from cell to cell, so we * also need different FEValues objects for different cells; once you * reinitialize the hp::FEValues object for a specific cell, it retrieves @@ -4194,7 +4194,7 @@ public: * * Though it seems that it is not very useful, this function is there to * provide capability to the hp::FEValues class, in which case it provides - * the FEValues object for the present cell (remember that for hp finite + * the FEValues object for the present cell (remember that for hp-finite * elements, the actual FE object used may change from cell to cell, so we * also need different FEValues objects for different cells; once you * reinitialize the hp::FEValues object for a specific cell, it retrieves diff --git a/include/deal.II/grid/grid_tools.h b/include/deal.II/grid/grid_tools.h index ebf7e40cb1..59c6425942 100644 --- a/include/deal.II/grid/grid_tools.h +++ b/include/deal.II/grid/grid_tools.h @@ -1252,7 +1252,7 @@ namespace GridTools /** * Another version where we use that mapping on a given * cell that corresponds to the active finite element index of that cell. - * This is obviously only useful for hp problems, since the active finite + * This is obviously only useful for hp-problems, since the active finite * element index for all other DoF handlers is always zero. */ template diff --git a/include/deal.II/hp/dof_handler.h b/include/deal.II/hp/dof_handler.h index 62de381d43..26fd3e93cb 100644 --- a/include/deal.II/hp/dof_handler.h +++ b/include/deal.II/hp/dof_handler.h @@ -45,7 +45,7 @@ namespace hp * The whole process of working with objects of this type is explained in * step-27. Many of the algorithms this class implements are described in * the - * @ref hp_paper "hp paper". + * @ref hp_paper "hp-paper". * * *

    Active FE indices and their behavior under mesh refinement

    diff --git a/include/deal.II/hp/fe_collection.h b/include/deal.II/hp/fe_collection.h index 4efb7d9a0d..07a32368ef 100644 --- a/include/deal.II/hp/fe_collection.h +++ b/include/deal.II/hp/fe_collection.h @@ -52,7 +52,7 @@ namespace hp { public: /** - * Whenever p adaptivity is considered in an hp finite element program, + * Whenever p-adaptivity is considered in an hp-finite element program, * a hierarchy of finite elements needs to be established to determine * succeeding finite elements for refinement and preceding ones for * coarsening. @@ -283,10 +283,10 @@ namespace hp /** * Return whether all elements in this collection implement the hanging * node constraints in the new way, which has to be used to make elements - * "hp compatible". If this is not the case, the function returns false, + * "hp-compatible". If this is not the case, the function returns false, * which implies, that at least one element in the FECollection does not * support the new face interface constraints. On the other hand, if this - * method does return true, this does not imply that the hp method will + * method does return true, this does not imply that the hp-method will * work! * * This behavior is related to the fact, that FiniteElement classes, diff --git a/include/deal.II/hp/fe_values.h b/include/deal.II/hp/fe_values.h index 23ce1556b3..f4dfefe931 100644 --- a/include/deal.II/hp/fe_values.h +++ b/include/deal.II/hp/fe_values.h @@ -60,7 +60,7 @@ namespace hp * second the dimensionality of the object that we integrate on, i.e. for * usual @p hp::FEValues it is equal to the first one, while for face * integration it is one less. The third template parameter indicates the - * type of underlying non-hp FE*Values base type, i.e. it could either be + * type of underlying non-hp-FE*Values base type, i.e. it could either be * ::FEValues, ::FEFaceValues, or ::FESubfaceValues. * * @ingroup hp @@ -231,11 +231,11 @@ namespace hp namespace hp { /** - * An hp equivalent of the ::FEValues class. See the step-27 tutorial + * An hp-equivalent of the ::FEValues class. See the step-27 tutorial * program for examples of use. * * The idea of this class is as follows: when one assembled matrices in the - * hp finite element method, there may be different finite elements on + * hp-finite element method, there may be different finite elements on * different cells, and consequently one may also want to use different * quadrature formulas for different cells. On the other hand, the * ::FEValues efficiently handles pre-evaluating whatever information is @@ -255,7 +255,7 @@ namespace hp * ::FEValues object that then fits the finite element and quadrature * formula for the current cell can then be accessed using the * get_present_fe_values() function, and one would work with it just like - * with any ::FEValues object for non-hp DoF handler objects. + * with any ::FEValues object for non-hp-DoFHandler objects. * * The reinit() functions have additional arguments with default values. If * not specified, the function takes the index into the hp::FECollection, @@ -336,7 +336,7 @@ namespace hp * quadrature formula for each finite element in the hp::FECollection. As * a special case, if the quadrature collection contains only a single * element (a frequent case if one wants to use the same quadrature object - * for all finite elements in an hp discretization, even if that may not + * for all finite elements in an hp-discretization, even if that may not * be the most efficient), then this single quadrature is used unless a * different value for this argument is specified. On the other hand, if a * value is given for this argument, it overrides the choice of @@ -349,7 +349,7 @@ namespace hp * cell-@>active_fe_index(), i.e. the same index as that of * the finite element. As above, if the mapping collection contains only a * single element (a frequent case if one wants to use a $Q_1$ mapping for - * all finite elements in an hp discretization), then this single mapping + * all finite elements in an hp-discretization), then this single mapping * is used unless a different value for this argument is specified. */ template @@ -455,7 +455,7 @@ namespace hp * quadrature formula for each finite element in the hp::FECollection. As * a special case, if the quadrature collection contains only a single * element (a frequent case if one wants to use the same quadrature object - * for all finite elements in an hp discretization, even if that may not + * for all finite elements in an hp-discretization, even if that may not * be the most efficient), then this single quadrature is used unless a * different value for this argument is specified. On the other hand, if a * value is given for this argument, it overrides the choice of @@ -468,7 +468,7 @@ namespace hp * cell-@>active_fe_index(), i.e. the same index as that of * the finite element. As above, if the mapping collection contains only a * single element (a frequent case if one wants to use a $Q_1$ mapping for - * all finite elements in an hp discretization), then this single mapping + * all finite elements in an hp-discretization), then this single mapping * is used unless a different value for this argument is specified. */ template @@ -576,7 +576,7 @@ namespace hp * quadrature formula for each finite element in the hp::FECollection. As * a special case, if the quadrature collection contains only a single * element (a frequent case if one wants to use the same quadrature object - * for all finite elements in an hp discretization, even if that may not + * for all finite elements in an hp-discretization, even if that may not * be the most efficient), then this single quadrature is used unless a * different value for this argument is specified. On the other hand, if a * value is given for this argument, it overrides the choice of @@ -589,7 +589,7 @@ namespace hp * cell-@>active_fe_index(), i.e. the same index as that of * the finite element. As above, if the mapping collection contains only a * single element (a frequent case if one wants to use a $Q_1$ mapping for - * all finite elements in an hp discretization), then this single mapping + * all finite elements in an hp-discretization), then this single mapping * is used unless a different value for this argument is specified. */ template diff --git a/include/deal.II/hp/refinement.h b/include/deal.II/hp/refinement.h index 12b01f6ac7..a8ae7ebdec 100644 --- a/include/deal.II/hp/refinement.h +++ b/include/deal.II/hp/refinement.h @@ -620,7 +620,7 @@ namespace hp * * @note The function Triangulation::prepare_coarsening_and_refinement() * will clean up all h-coarsening flags if they are not shared among - * all siblings. In the hp case, we need to bring forward this decision: + * all siblings. In the hp-case, we need to bring forward this decision: * If the cell will not be coarsened, but qualifies for p-adaptivity, * we have to set all flags accordingly. So this function anticipates * the decision that Triangulation::prepare_coarsening_and_refinement() diff --git a/include/deal.II/lac/affine_constraints.h b/include/deal.II/lac/affine_constraints.h index 6e4b0ed965..61b04ad70c 100644 --- a/include/deal.II/lac/affine_constraints.h +++ b/include/deal.II/lac/affine_constraints.h @@ -443,7 +443,7 @@ class AffineConstraints; * * The algorithms used in the implementation of this class are described in * some detail in the - * @ref hp_paper "hp paper". + * @ref hp_paper "hp-paper". * There is also a significant amount of documentation on how to use this * class in the * @ref constraints @@ -1442,7 +1442,7 @@ public: * sparsity pattern entries. * * As explained in the - * @ref hp_paper "hp paper" + * @ref hp_paper "hp-paper" * and in step-27, first allocating a sparsity pattern and later coming back * and allocating additional entries for those matrix entries that will be * written to due to the elimination of constrained degrees of freedom diff --git a/include/deal.II/matrix_free/dof_info.h b/include/deal.II/matrix_free/dof_info.h index e1b1c5f271..f1a2dc13ae 100644 --- a/include/deal.II/matrix_free/dof_info.h +++ b/include/deal.II/matrix_free/dof_info.h @@ -129,9 +129,9 @@ namespace internal clear(); /** - * Return the FE index for a given finite element degree. If not in hp + * Return the FE index for a given finite element degree. If not in hp- * mode, this function always returns index 0. If an index is not found - * in hp mode, it returns numbers::invalid_unsigned_int. + * in hp-mode, it returns numbers::invalid_unsigned_int. */ unsigned int fe_index_from_degree(const unsigned int first_selected_component, @@ -634,7 +634,7 @@ namespace internal * account. This information is encoded in the row_starts variables * directly. * - * The outer vector goes through the various fe indices in the hp case, + * The outer vector goes through the various fe indices in the hp-case, * similarly to the @p dofs_per_cell variable. */ std::vector> component_dof_indices_offset; @@ -655,20 +655,20 @@ namespace internal bool store_plain_indices; /** - * Stores the index of the active finite element in the hp case. + * Stores the index of the active finite element in the hp-case. */ std::vector cell_active_fe_index; /** - * Stores the maximum degree of different finite elements for the hp + * Stores the maximum degree of different finite elements for the hp- * case. */ unsigned int max_fe_index; /** - * To each of the slots in an hp adaptive case, the inner vector stores + * To each of the slots in an hp-adaptive case, the inner vector stores * the corresponding element degree. This is used by the constructor of - * FEEvaluationBase to identify the correct data slot in the hp case. + * FEEvaluationBase to identify the correct data slot in the hp-case. */ std::vector> fe_index_conversion; diff --git a/include/deal.II/matrix_free/fe_evaluation.h b/include/deal.II/matrix_free/fe_evaluation.h index 0f42479794..3662a970c4 100644 --- a/include/deal.II/matrix_free/fe_evaluation.h +++ b/include/deal.II/matrix_free/fe_evaluation.h @@ -257,7 +257,7 @@ public: get_current_cell_index() const; /** - * Return the active fe index for this class for efficient indexing in the hp + * Return the active fe index for this class for efficient indexing in the hp- * case. */ unsigned int @@ -265,7 +265,7 @@ public: /** * Return the active quadrature index for this class for efficient indexing in - * the hp case. + * the hp-case. */ unsigned int get_active_quadrature_index() const; @@ -360,13 +360,13 @@ protected: VectorizedArrayType> *mapping_data; /** - * The active fe index for this class for efficient indexing in the hp case. + * The active fe index for this class for efficient indexing in the hp-case. */ const unsigned int active_fe_index; /** * The active quadrature index for this class for efficient indexing in the - * hp case. + * hp-case. */ const unsigned int active_quad_index; diff --git a/include/deal.II/matrix_free/mapping_info.h b/include/deal.II/matrix_free/mapping_info.h index dc63926076..8c0d0c77d4 100644 --- a/include/deal.II/matrix_free/mapping_info.h +++ b/include/deal.II/matrix_free/mapping_info.h @@ -104,7 +104,7 @@ namespace internal * The third component is a descriptor of data from the unit cells, called * QuadratureDescriptor, which contains the quadrature weights and * permutations of how to go through quadrature points in case of face - * data. The latter comes in a vector for the support of hp adaptivity, + * data. The latter comes in a vector for the support of hp-adaptivity, * with several data fields for the individual quadrature formulas. * * @ingroup matrixfree @@ -188,7 +188,7 @@ namespace internal /** * A class describing the layout of the sections in the @p data_storage * field and also includes some data that depends on the number of - * quadrature points in the hp context such as the inner quadrature + * quadrature points in the hp-context such as the inner quadrature * formula and re-indexing for faces that are not in the standard * orientation. */ @@ -289,7 +289,7 @@ namespace internal /** * Returns the quadrature index for a given number of quadrature - * points. If not in hp mode or if the index is not found, this + * points. If not in hp-mode or if the index is not found, this * function always returns index 0. Hence, this function does not * check whether the given degree is actually present. */ @@ -456,7 +456,7 @@ namespace internal /** * Internal function to compute the geometry for the case the mapping is - * a MappingQ and a single quadrature formula per slot (non-hp case) is + * a MappingQ and a single quadrature formula per slot (non-hp-case) is * used. This method computes all data from the underlying cell * quadrature points using the fast operator evaluation techniques from * the matrix-free framework itself, i.e., it uses a polynomial diff --git a/include/deal.II/matrix_free/mapping_info.templates.h b/include/deal.II/matrix_free/mapping_info.templates.h index c2d822fff7..d6cddd792b 100644 --- a/include/deal.II/matrix_free/mapping_info.templates.h +++ b/include/deal.II/matrix_free/mapping_info.templates.h @@ -460,7 +460,7 @@ namespace internal } } - // In case we have no hp adaptivity (active_fe_index is empty), we have + // In case we have no hp-adaptivity (active_fe_index is empty), we have // cells, and the mapping is MappingQGeneric or a derived class, we can // use the fast method. if (active_fe_index.empty() && !cells.empty() && mapping->size() == 1 && @@ -904,7 +904,7 @@ namespace internal GeometryType cell_t_prev = general; // fe_values object that is used to compute the mapping data. for - // the hp case there might be more than one finite element. since we + // the hp-case there might be more than one finite element. since we // manually select the active FE index and not via a // DoFHandler::active_cell_iterator, we need to manually // select the correct finite element, so just hold a vector of @@ -1840,7 +1840,7 @@ namespace internal ++my_q) { #ifndef DEAL_II_WITH_SIMPLEX_SUPPORT - // currently only non-hp case... + // currently only non-hp-case... AssertDimension(mapping_in.size(), 1); AssertDimension(mapping_info.face_data[my_q].descriptor.size(), 1); diff --git a/include/deal.II/matrix_free/matrix_free.h b/include/deal.II/matrix_free/matrix_free.h index e04a41b761..1f82ed4fd7 100644 --- a/include/deal.II/matrix_free/matrix_free.h +++ b/include/deal.II/matrix_free/matrix_free.h @@ -163,7 +163,7 @@ public: * The two parameters `cell_vectorization_categories` and * `cell_vectorization_categories_strict` control the formation of batches * for vectorization over several cells. It is used implicitly when working - * with hp adaptivity but can also be useful in other contexts, such as in + * with hp-adaptivity but can also be useful in other contexts, such as in * local time stepping where one would like to control which elements * together form a batch of cells. The array `cell_vectorization_categories` * is accessed by the number given by cell->active_cell_index() when working @@ -511,7 +511,7 @@ public: /** * This data structure allows to assign a fraction of cells to different * categories when building the information for vectorization. It is used - * implicitly when working with hp adaptivity but can also be useful in + * implicitly when working with hp-adaptivity but can also be useful in * other contexts, such as in local time stepping where one would like to * control which elements together form a batch of cells. * @@ -1458,7 +1458,7 @@ public: DataAccessOnFaces::unspecified) const; /** - * In the hp adaptive case, a subrange of cells as computed during the cell + * In the hp-adaptive case, a subrange of cells as computed during the cell * loop might contain elements of different degrees. Use this function to * compute what the subrange for an individual finite element degree is. The * finite element degree is associated to the vector component given in the @@ -1470,9 +1470,9 @@ public: const unsigned int dof_handler_index = 0) const; /** - * In the hp adaptive case, a subrange of cells as computed during the cell + * In the hp-adaptive case, a subrange of cells as computed during the cell * loop might contain elements of different degrees. Use this function to - * compute what the subrange for a given index the hp finite element, as + * compute what the subrange for a given index the hp-finite element, as * opposed to the finite element degree in the other function. */ std::pair @@ -1482,7 +1482,7 @@ public: const unsigned int dof_handler_index = 0) const; /** - * In the hp adaptive case, a subrange of internal faces as computed during + * In the hp-adaptive case, a subrange of internal faces as computed during * loop() might contain internal faces with elements of different active * fe indices. Use this function to compute what the subrange for a given pair * of active fe indices is. @@ -1495,7 +1495,7 @@ public: const unsigned int dof_handler_index = 0) const; /** - * In the hp adaptive case, a subrange of boundary faces as computed during + * In the hp-adaptive case, a subrange of boundary faces as computed during * loop() might contain boundary faces with elements of different active * fe indices. Use this function to compute what the subrange for a given * active fe indices is. @@ -1507,20 +1507,20 @@ public: const unsigned int dof_handler_index = 0) const; /** - * In the hp adaptive case, return number of active_fe_indices. + * In the hp-adaptive case, return number of active_fe_indices. */ unsigned int n_active_fe_indices() const; /** - * In the hp adaptive case, return the active_fe_index of a cell range. + * In the hp-adaptive case, return the active_fe_index of a cell range. */ unsigned int get_cell_active_fe_index( const std::pair range) const; /** - * In the hp adaptive case, return the active_fe_index of a face range. + * In the hp-adaptive case, return the active_fe_index of a face range. */ unsigned int get_face_active_fe_index(const std::pair range, @@ -1862,14 +1862,14 @@ public: n_active_entries_per_face_batch(const unsigned int face_batch_index) const; /** - * Return the number of degrees of freedom per cell for a given hp index. + * Return the number of degrees of freedom per cell for a given hp-index. */ unsigned int get_dofs_per_cell(const unsigned int dof_handler_index = 0, const unsigned int hp_active_fe_index = 0) const; /** - * Return the number of quadrature points per cell for a given hp index. + * Return the number of quadrature points per cell for a given hp-index. */ unsigned int get_n_q_points(const unsigned int quad_index = 0, @@ -1877,7 +1877,7 @@ public: /** * Return the number of degrees of freedom on each face of the cell for - * given hp index. + * given hp-index. */ unsigned int get_dofs_per_face(const unsigned int dof_handler_index = 0, @@ -1885,21 +1885,21 @@ public: /** * Return the number of quadrature points on each face of the cell for - * given hp index. + * given hp-index. */ unsigned int get_n_q_points_face(const unsigned int quad_index = 0, const unsigned int hp_active_fe_index = 0) const; /** - * Return the quadrature rule for given hp index. + * Return the quadrature rule for given hp-index. */ const Quadrature & get_quadrature(const unsigned int quad_index = 0, const unsigned int hp_active_fe_index = 0) const; /** - * Return the quadrature rule for given hp index. + * Return the quadrature rule for given hp-index. */ const Quadrature & get_face_quadrature(const unsigned int quad_index = 0, @@ -1908,7 +1908,7 @@ public: /** * Return the category the current batch of cells was assigned to. Categories * run between the given values in the field - * AdditionalData::cell_vectorization_category for non-hp DoFHandler types + * AdditionalData::cell_vectorization_category for non-hp-DoFHandler types * and return the active FE index in the hp-adaptive case. */ unsigned int @@ -2012,7 +2012,7 @@ public: constraint_pool_end(const unsigned int pool_index) const; /** - * Return the unit cell information for given hp index. + * Return the unit cell information for given hp-index. */ const internal::MatrixFreeFunctions::ShapeInfo & get_shape_info(const unsigned int dof_handler_index_component = 0, diff --git a/include/deal.II/matrix_free/matrix_free.templates.h b/include/deal.II/matrix_free/matrix_free.templates.h index cba9b410ae..b2f3fab893 100644 --- a/include/deal.II/matrix_free/matrix_free.templates.h +++ b/include/deal.II/matrix_free/matrix_free.templates.h @@ -106,7 +106,7 @@ MatrixFree::create_cell_subrange_hp_by_index( Assert( fe_indices[i] >= fe_indices[i - 1], ExcMessage( - "Cell range must be over sorted range of fe indices in hp case!")); + "Cell range must be over sorted range of fe indices in hp-case!")); AssertIndexRange(range.first, fe_indices.size() + 1); AssertIndexRange(range.second, fe_indices.size() + 1); #endif @@ -579,7 +579,7 @@ MatrixFree::internal_reinit( { if (dof_handler.size() > 1) { - // check if all DoHandlers are in the same hp mode; and if hp + // check if all DoHandlers are in the same hp-mode; and if hp- // capabilities are enabled: check if active_fe_indices of all // DoFHandler are the same. for (unsigned int i = 1; i < dof_handler.size(); ++i) diff --git a/include/deal.II/matrix_free/task_info.h b/include/deal.II/matrix_free/task_info.h index 322b863ddb..d985c3a570 100644 --- a/include/deal.II/matrix_free/task_info.h +++ b/include/deal.II/matrix_free/task_info.h @@ -151,7 +151,7 @@ namespace internal * interleaving cell and face integrals. * * @param categories_are_hp Defines whether - * `cell_vectorization_categories` is originating from a hp adaptive + * `cell_vectorization_categories` is originating from a hp-adaptive * computation with variable polynomial degree or a user-defined * variant. * @@ -246,7 +246,7 @@ namespace internal * some SIMD lanes in VectorizedArray would not be filled for a given * cell batch index. * - * @param hp_bool Defines whether we are in hp mode or not + * @param hp_bool Defines whether we are in hp-mode or not */ void make_thread_graph_partition_color( @@ -285,7 +285,7 @@ namespace internal * some SIMD lanes in VectorizedArray would not be filled for a given * cell batch index. * - * @param hp_bool Defines whether we are in hp mode or not + * @param hp_bool Defines whether we are in hp-mode or not */ void make_thread_graph_partition_partition( @@ -316,7 +316,7 @@ namespace internal * some SIMD lanes in VectorizedArray would not be filled for a given * cell batch index. * - * @param hp_bool Defines whether we are in hp mode or not + * @param hp_bool Defines whether we are in hp-mode or not */ void make_thread_graph(const std::vector &cell_active_fe_index, diff --git a/include/deal.II/multigrid/mg_transfer_global_coarsening.h b/include/deal.II/multigrid/mg_transfer_global_coarsening.h index b1fd856f59..dc88c7e8fa 100644 --- a/include/deal.II/multigrid/mg_transfer_global_coarsening.h +++ b/include/deal.II/multigrid/mg_transfer_global_coarsening.h @@ -38,7 +38,7 @@ namespace internal /** - * Class for transfer between two multigrid levels for p or global coarsening. + * Class for transfer between two multigrid levels for p- or global coarsening. */ template class MGTwoLevelTransfer @@ -60,7 +60,7 @@ public: /** - * Class for transfer between two multigrid levels for p or global coarsening. + * Class for transfer between two multigrid levels for p- or global coarsening. * Specialization for LinearAlgebra::distributed::Vector. */ template diff --git a/include/deal.II/numerics/error_estimator.h b/include/deal.II/numerics/error_estimator.h index 220b3fc692..e7e4bf2208 100644 --- a/include/deal.II/numerics/error_estimator.h +++ b/include/deal.II/numerics/error_estimator.h @@ -429,7 +429,7 @@ public: /** * Equivalent to the set of functions above, except that this one takes a - * quadrature collection for hp finite element dof handlers. + * quadrature collection for hp-finite element dof handlers. */ template static void @@ -452,7 +452,7 @@ public: /** * Equivalent to the set of functions above, except that this one takes a - * quadrature collection for hp finite element dof handlers. + * quadrature collection for hp-finite element dof handlers. */ template static void @@ -474,7 +474,7 @@ public: /** * Equivalent to the set of functions above, except that this one takes a - * quadrature collection for hp finite element dof handlers. + * quadrature collection for hp-finite element dof handlers. */ template static void @@ -497,7 +497,7 @@ public: /** * Equivalent to the set of functions above, except that this one takes a - * quadrature collection for hp finite element dof handlers. + * quadrature collection for hp-finite element dof handlers. */ template static void @@ -715,7 +715,7 @@ public: /** * Equivalent to the set of functions above, except that this one takes a - * quadrature collection for hp finite element dof handlers. + * quadrature collection for hp-finite element dof handlers. */ template static void @@ -738,7 +738,7 @@ public: /** * Equivalent to the set of functions above, except that this one takes a - * quadrature collection for hp finite element dof handlers. + * quadrature collection for hp-finite element dof handlers. */ template static void @@ -760,7 +760,7 @@ public: /** * Equivalent to the set of functions above, except that this one takes a - * quadrature collection for hp finite element dof handlers. + * quadrature collection for hp-finite element dof handlers. */ template static void @@ -783,7 +783,7 @@ public: /** * Equivalent to the set of functions above, except that this one takes a - * quadrature collection for hp finite element dof handlers. + * quadrature collection for hp-finite element dof handlers. */ template static void diff --git a/include/deal.II/numerics/error_estimator.templates.h b/include/deal.II/numerics/error_estimator.templates.h index beb539b0aa..5b72586f20 100644 --- a/include/deal.II/numerics/error_estimator.templates.h +++ b/include/deal.II/numerics/error_estimator.templates.h @@ -84,7 +84,7 @@ namespace internal * needs not allocate memory itself, or synchronize with other threads. * * The sizes of the arrays are initialized with the maximal number of - * entries necessary for the hp case. Within the loop over individual + * entries necessary for the hp-case. Within the loop over individual * cells, we then resize the arrays as necessary. Since for std::vector * resizing to a smaller size doesn't imply memory allocation, this is * fast. @@ -195,7 +195,7 @@ namespace internal /** * Resize the arrays so that they fit the number of quadrature points - * associated with the given finite element index into the hp + * associated with the given finite element index into the hp- * collections. */ void @@ -700,7 +700,7 @@ namespace internal ExcInternalError()); // get restriction of finite element function of @p{neighbor} to the - // common face. in the hp case, use the quadrature formula that + // common face. in the hp-case, use the quadrature formula that // matches the one we would use for the present cell fe_face_values_neighbor.reinit(neighbor, neighbor_neighbor, diff --git a/include/deal.II/numerics/matrix_tools.h b/include/deal.II/numerics/matrix_tools.h index c0052ff617..52169804de 100644 --- a/include/deal.II/numerics/matrix_tools.h +++ b/include/deal.II/numerics/matrix_tools.h @@ -318,7 +318,7 @@ namespace MatrixCreator const AffineConstraints &constraints = AffineConstraints()); /** - * Same function as above, but for hp objects. + * Same function as above, but for hp-objects. */ template void @@ -331,7 +331,7 @@ namespace MatrixCreator const AffineConstraints &constraints = AffineConstraints()); /** - * Same function as above, but for hp objects. + * Same function as above, but for hp-objects. */ template void @@ -343,7 +343,7 @@ namespace MatrixCreator const AffineConstraints &constraints = AffineConstraints()); /** - * Same function as above, but for hp objects. + * Same function as above, but for hp-objects. */ template void @@ -358,7 +358,7 @@ namespace MatrixCreator const AffineConstraints &constraints = AffineConstraints()); /** - * Same function as above, but for hp objects. + * Same function as above, but for hp-objects. */ template void @@ -430,7 +430,7 @@ namespace MatrixCreator std::vector component_mapping = {}); /** - * Same function as above, but for hp objects. + * Same function as above, but for hp-objects. */ template void @@ -447,7 +447,7 @@ namespace MatrixCreator std::vector component_mapping = {}); /** - * Same function as above, but for hp objects. + * Same function as above, but for hp-objects. */ template void @@ -550,8 +550,7 @@ namespace MatrixCreator const AffineConstraints &constraints = AffineConstraints()); /** - * Like the functions above, but for hp dof handlers, mappings, and - * quadrature collections. + * Like the functions above, but for hp-objects. */ template void @@ -564,8 +563,7 @@ namespace MatrixCreator const AffineConstraints &constraints = AffineConstraints()); /** - * Like the functions above, but for hp dof handlers, mappings, and - * quadrature collections. + * Like the functions above, but for hp-objects. */ template void @@ -577,8 +575,7 @@ namespace MatrixCreator const AffineConstraints &constraints = AffineConstraints()); /** - * Like the functions above, but for hp dof handlers, mappings, and - * quadrature collections. + * Like the functions above, but for hp-objects. */ template void @@ -593,8 +590,7 @@ namespace MatrixCreator const AffineConstraints &constraints = AffineConstraints()); /** - * Like the functions above, but for hp dof handlers, mappings, and - * quadrature collections. + * Like the functions above, but for hp-objects. */ template void diff --git a/include/deal.II/numerics/solution_transfer.h b/include/deal.II/numerics/solution_transfer.h index ddaa04566e..2da1e585e9 100644 --- a/include/deal.II/numerics/solution_transfer.h +++ b/include/deal.II/numerics/solution_transfer.h @@ -291,7 +291,7 @@ DEAL_II_NAMESPACE_OPEN * necessary to call AffineConstraints::distribute(). * * - *

    Implementation in the context of hp finite elements

    + *

    Implementation in the context of hp-finite elements

    * * In the case of DoFHandlers with hp-capabilities, nothing defines which of the * finite elements that are part of the hp::FECollection associated with the @@ -323,7 +323,7 @@ DEAL_II_NAMESPACE_OPEN * active_fe_index for a different space post-refinement and before calling * DoFHandler::distribute_dofs()). * - * @note In the context of hp refinement, if cells are coarsened or the + * @note In the context of hp-refinement, if cells are coarsened or the * polynomial degree is lowered on some cells, then the old finite element * space is not a subspace of the new space and you may run into the same * situation as discussed above with hanging nodes. You may want to consider diff --git a/include/deal.II/numerics/vector_tools_boundary.h b/include/deal.II/numerics/vector_tools_boundary.h index 6593be957b..69e7818119 100644 --- a/include/deal.II/numerics/vector_tools_boundary.h +++ b/include/deal.II/numerics/vector_tools_boundary.h @@ -625,7 +625,7 @@ namespace VectorTools * a problem when using the previous function in conjunction with non- * rectangular geometries (i.e. elements with non-rectangular faces). The * L2-projection method used has been taken from the paper "Electromagnetic - * scattering simulation using an H (curl) conforming hp finite element + * scattering simulation using an H (curl) conforming hp-finite element * method in three dimensions" by PD Ledger, K Morgan and O Hassan ( Int. J. * Num. Meth. Fluids, Volume 53, Issue 8, pages 1267-1296). * diff --git a/include/deal.II/numerics/vector_tools_boundary.templates.h b/include/deal.II/numerics/vector_tools_boundary.templates.h index 30168150f3..350ab9c5dc 100644 --- a/include/deal.II/numerics/vector_tools_boundary.templates.h +++ b/include/deal.II/numerics/vector_tools_boundary.templates.h @@ -2928,13 +2928,13 @@ namespace VectorTools // compute_face_projection_curl_conforming_l2 // // For details see (for example) section 4.2: - // Electromagnetic scattering simulation using an H (curl) conforming hp + // Electromagnetic scattering simulation using an H (curl) conforming hp- // finite element method in three dimensions, PD Ledger, K Morgan, O // Hassan, Int. J. Num. Meth. Fluids, Volume 53, Issue 8, pages // 1267-1296, 20 March 2007: // http://onlinelibrary.wiley.com/doi/10.1002/fld.1223/abstract - // Create hp FEcollection, dof_handler can be either hp or standard type. + // Create hp-FEcollection, dof_handler can be either hp- or standard type. // From here on we can treat it like a hp-namespace object. const hp::FECollection &fe_collection( dof_handler.get_fe_collection()); @@ -3216,7 +3216,7 @@ namespace VectorTools AffineConstraints & constraints, const Mapping & mapping) { - // non-hp version - calls the internal + // non-hp-version - calls the internal // compute_project_boundary_values_curl_conforming_l2() function // above after recasting the mapping. @@ -3240,7 +3240,7 @@ namespace VectorTools AffineConstraints & constraints, const hp::MappingCollection &mapping_collection) { - // hp version - calls the internal + // hp-version - calls the internal // compute_project_boundary_values_curl_conforming_l2() function above. internals::compute_project_boundary_values_curl_conforming_l2( dof_handler, diff --git a/include/deal.II/numerics/vector_tools_interpolate.h b/include/deal.II/numerics/vector_tools_interpolate.h index ee36053253..b13b173a50 100644 --- a/include/deal.II/numerics/vector_tools_interpolate.h +++ b/include/deal.II/numerics/vector_tools_interpolate.h @@ -73,7 +73,7 @@ namespace VectorTools const ComponentMask &component_mask = ComponentMask()); /** - * Same as above but in an hp context. + * Same as above but in an hp-context. */ template void diff --git a/include/deal.II/numerics/vector_tools_rhs.h b/include/deal.II/numerics/vector_tools_rhs.h index 34878b0ba3..d5894d315d 100644 --- a/include/deal.II/numerics/vector_tools_rhs.h +++ b/include/deal.II/numerics/vector_tools_rhs.h @@ -82,7 +82,7 @@ namespace VectorTools AffineConstraints()); /** - * Like the previous set of functions, but for hp objects. + * Like the previous set of functions, but for hp-objects. */ template void @@ -96,7 +96,7 @@ namespace VectorTools AffineConstraints()); /** - * Like the previous set of functions, but for hp objects. + * Like the previous set of functions, but for hp-objects. */ template void @@ -146,7 +146,7 @@ namespace VectorTools std::set()); /** - * Same as the set of functions above, but for hp objects. + * Same as the set of functions above, but for hp-objects. * * @see * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators" diff --git a/source/dofs/dof_accessor_get.cc b/source/dofs/dof_accessor_get.cc index 3baf6506d4..b920452d47 100644 --- a/source/dofs/dof_accessor_get.cc +++ b/source/dofs/dof_accessor_get.cc @@ -97,7 +97,7 @@ DoFCellAccessor::get_interpolated_dof_values( // children recursively. { // we are on a non-active cell. these do not have any finite - // element associated with them in the hp context (in the non-hp + // element associated with them in the hp-context (in the non-hp- // context, we can simply assume that the FE space to which we // want to interpolate is the same as for all elements in the // mesh). consequently, we cannot interpolate from children's FE diff --git a/source/dofs/dof_handler.cc b/source/dofs/dof_handler.cc index 427918db84..47ee62b991 100644 --- a/source/dofs/dof_handler.cc +++ b/source/dofs/dof_handler.cc @@ -2445,7 +2445,7 @@ DoFHandler::set_fe(const hp::FECollection &ff) AssertThrow( hp_capability_enabled || !contains_multiple_fes, ExcMessage( - "You cannot re-enable hp capabilities after you registered a single " + "You cannot re-enable hp-capabilities after you registered a single " "finite element. Please create a new DoFHandler object instead.")); } @@ -2524,7 +2524,7 @@ DoFHandler::distribute_dofs( AssertThrow( hp_capability_enabled || !contains_multiple_fes, ExcMessage( - "You cannot re-enable hp capabilities after you registered a single " + "You cannot re-enable hp-capabilities after you registered a single " "finite element. Please call reinit() or create a new DoFHandler " "object instead.")); } diff --git a/source/dofs/dof_handler_policy.cc b/source/dofs/dof_handler_policy.cc index c1c2ba7aaa..62f5531d9f 100644 --- a/source/dofs/dof_handler_policy.cc +++ b/source/dofs/dof_handler_policy.cc @@ -402,7 +402,7 @@ namespace internal dof_handler.get_triangulation()) .clear_user_flags_line(); - // An implementation of the algorithm described in the hp paper, + // An implementation of the algorithm described in the hp-paper, // including the modification mentioned later in the "complications in // 3-d" subsections // @@ -446,7 +446,7 @@ namespace internal fe_index_2 = line->nth_active_fe_index(g); - // as described in the hp paper, we only unify on lines + // as described in the hp-paper, we only unify on lines // when there are at most two different FE objects // assigned on it. // however, more than two 'active_fe_indices' can be @@ -777,7 +777,7 @@ namespace internal dof_handler.get_triangulation()) .clear_user_flags_quad(); - // An implementation of the algorithm described in the hp + // An implementation of the algorithm described in the hp- // paper, including the modification mentioned later in the // "complications in 3-d" subsections // @@ -1020,7 +1020,7 @@ namespace internal /** * Once degrees of freedom have been distributed on all cells, see if * we can identify DoFs on neighboring cells. This function does - * nothing unless the DoFHandler has hp capabilities. + * nothing unless the DoFHandler has hp-capabilities. * * Return the final number of degrees of freedom, which is the old one * minus however many were identified. @@ -1252,7 +1252,7 @@ namespace internal for (const auto l : cell->line_indices()) cell->line(l)->set_user_flag(); - // An implementation of the algorithm described in the hp paper, + // An implementation of the algorithm described in the hp-paper, // including the modification mentioned later in the "complications in // 3-d" subsections // @@ -1533,7 +1533,7 @@ namespace internal for (const auto q : cell->face_indices()) cell->quad(q)->set_user_flag(); - // An implementation of the algorithm described in the hp + // An implementation of the algorithm described in the hp- // paper, including the modification mentioned later in the // "complications in 3-d" subsections // @@ -1649,7 +1649,7 @@ namespace internal * know the indices of all dominating DoFs, and we have to assign those * invalid entries to their corresponding global value. * - * This function does nothing unless the DoFHandler has hp + * This function does nothing unless the DoFHandler has hp- * capabilities. */ template @@ -1958,7 +1958,7 @@ namespace internal // non-locally owned DoF for which we don't know the // new number yet and so set it to an invalid index. // This will later be fixed up after the first ghost - // exchange phase when we unify hp DoFs on neighboring + // exchange phase when we unify hp-DoFs on neighboring // cells. if (indices_we_care_about.size() == 0) dealii::internal::DoFAccessorImplementation:: @@ -2052,7 +2052,7 @@ namespace internal // DoF for which we don't know the new number yet and so // set it to an invalid index. This will later be fixed // up after the first ghost exchange phase when we unify - // hp DoFs on neighboring cells. + // hp-DoFs on neighboring cells. if (indices_we_care_about.size() == 0) cell->set_dof_index(d, new_numbers[old_dof_index], @@ -2163,7 +2163,7 @@ namespace internal // for which we don't know the new number yet // and so set it to an invalid index. This // will later be fixed up after the first - // ghost exchange phase when we unify hp DoFs + // ghost exchange phase when we unify hp-DoFs // on neighboring cells. if (indices_we_care_about.size() == 0) line->set_dof_index( @@ -2272,7 +2272,7 @@ namespace internal // for which we don't know the new number yet // and so set it to an invalid index. This // will later be fixed up after the first - // ghost exchange phase when we unify hp DoFs + // ghost exchange phase when we unify hp-DoFs // on neighboring cells. if (indices_we_care_about.size() == 0) line->set_dof_index( @@ -2350,7 +2350,7 @@ namespace internal // for which we don't know the new number yet // and so set it to an invalid index. This // will later be fixed up after the first - // ghost exchange phase when we unify hp DoFs + // ghost exchange phase when we unify hp-DoFs // on neighboring cells. if (indices_we_care_about.size() == 0) quad->set_dof_index( @@ -2845,7 +2845,7 @@ namespace internal // return a sequential, complete index set. take into account that the // number of DoF indices may in fact be smaller than there were before // if some previously separately numbered dofs have been identified. - // this is, for example, what we do when the DoFHandler has hp + // this is, for example, what we do when the DoFHandler has hp- // capabilities enabled: it first enumerates all DoFs on cells // independently, and then unifies some located at vertices or faces; // this leaves us with fewer DoFs than there were before, so use the @@ -3819,7 +3819,7 @@ namespace internal // --------- Phase 2: eliminate dof duplicates on all cells: // - un-numerate dofs on interfaces to ghost cells // that we don't own - // - in case of hp support, unify dofs + // - in case of hp-support, unify dofs std::vector renumbering( n_initial_local_dofs, enumeration_dof_index); @@ -3830,7 +3830,7 @@ namespace internal invalidate_dof_indices_on_weaker_ghost_cells_for_renumbering( renumbering, subdomain_id, *dof_handler); - // then, we identify DoF duplicates if the DoFHandler has hp + // then, we identify DoF duplicates if the DoFHandler has hp- // capabilities std::vector> all_constrained_indices(dim); @@ -3917,7 +3917,7 @@ namespace internal // done twice communicate_dof_indices_on_marked_cells(*dof_handler); - // If the DoFHandler has hp capabilities enabled, then we may have + // If the DoFHandler has hp-capabilities enabled, then we may have // received valid indices of degrees of freedom that are dominated // by a fe object adjacent to a ghost interface. thus, we overwrite // the remaining invalid indices with the valid ones in this step. @@ -4410,7 +4410,7 @@ namespace internal // // This is the same as phase 5+6 in the distribute_dofs() algorithm, // taking into account that we have to unify a few DoFs in between - // then communication phases if we do hp numbering + // then communication phases if we do hp-numbering { std::vector user_flags; triangulation->save_user_flags(user_flags); @@ -4430,7 +4430,7 @@ namespace internal // done twice communicate_dof_indices_on_marked_cells(*dof_handler); - // if the DoFHandler has hp capabilities then we may have + // if the DoFHandler has hp-capabilities then we may have // received valid indices of degrees of freedom that are // dominated by a fe object adjacent to a ghost interface. // thus, we overwrite the remaining invalid indices with the diff --git a/source/dofs/dof_objects.cc b/source/dofs/dof_objects.cc index 5d55b546e6..e7e593cca3 100644 --- a/source/dofs/dof_objects.cc +++ b/source/dofs/dof_objects.cc @@ -50,7 +50,7 @@ namespace internal Assert( (fe_index == dealii::DoFHandler::default_fe_index), ExcMessage( - "Only the default FE index is allowed for non-hp DoFHandler objects")); + "Only the default FE index is allowed for non-hp-DoFHandler objects")); Assert( local_index < dof_handler.get_fe().template n_dofs_per_object(), ExcIndexRange(local_index, diff --git a/source/dofs/dof_renumbering.inst.in b/source/dofs/dof_renumbering.inst.in index 624e4a33b9..79a1678658 100644 --- a/source/dofs/dof_renumbering.inst.in +++ b/source/dofs/dof_renumbering.inst.in @@ -21,7 +21,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) \{ namespace boost \{ - // TODO[WB]: also implement the following boost for hp DoFHandlers etc. + // TODO[WB]: also implement the following boost for hp-DoFHandlers etc. \} @@ -78,7 +78,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) \{ namespace boost \{ - // TODO[WB]: also implement the following boost for hp DoFHandlers etc. + // TODO[WB]: also implement the following boost for hp-DoFHandlers etc. template void Cuthill_McKee(DoFHandler &, bool, bool); diff --git a/source/dofs/dof_tools_constraints.cc b/source/dofs/dof_tools_constraints.cc index 4f50b8db7c..d1998c278f 100644 --- a/source/dofs/dof_tools_constraints.cc +++ b/source/dofs/dof_tools_constraints.cc @@ -149,7 +149,7 @@ namespace DoFTools /** * When restricting, on a face, the degrees of freedom of fe1 to the space * described by fe2 (for example for the complex case described - * in the @ref hp_paper "hp paper"), we have to select fe2.dofs_per_face + * in the @ref hp_paper "hp-paper"), we have to select fe2.dofs_per_face * out of the fe1.dofs_per_face face DoFs as the * primary dofs, and the rest become dependent dofs. This function selects * which ones will be primary, and which ones will be dependents. @@ -395,7 +395,7 @@ namespace DoFTools /** * Given the face interpolation matrix between two elements, split it into * its primary and dependent parts and invert the primary part as - * explained in the @ref hp_paper "hp paper". + * explained in the @ref hp_paper "hp-paper". */ void ensure_existence_of_split_face_matrix( @@ -457,7 +457,7 @@ namespace DoFTools /** * A function that returns how many different finite elements a dof - * handler uses. This is one for non-hp DoFHandlers and + * handler uses. This is one for non-hp-DoFHandlers and * dof_handler.get_fe().size() for the hp-versions. */ template @@ -476,7 +476,7 @@ namespace DoFTools * Copy constraints into an AffineConstraints object. * * This function removes zero constraints and those, which constrain a DoF - * which was already eliminated in one of the previous steps of the hp + * which was already eliminated in one of the previous steps of the hp- * hanging node procedure. * * It also suppresses very small entries in the AffineConstraints object @@ -1016,7 +1016,7 @@ namespace DoFTools AffineConstraints & constraints) { // note: this function is going to be hard to understand if you haven't - // read the hp paper. however, we try to follow the notation laid out + // read the hp-paper. however, we try to follow the notation laid out // there, so go read the paper before you try to understand what is going // on here @@ -1046,7 +1046,7 @@ namespace DoFTools // primary and dependent parts, and for which the primary part is // inverted. these two matrices are derived from the face interpolation // matrix - // as described in the @ref hp_paper "hp paper" + // as described in the @ref hp_paper "hp-paper" Table<2, std::unique_ptr, FullMatrix>>> split_face_interpolation_matrices(n_finite_elements(dof_handler), @@ -1104,7 +1104,7 @@ namespace DoFTools ExcInternalError()); // first find out whether we can constrain each of the subfaces - // to the mother face. in the lingo of the hp paper, this would + // to the mother face. in the lingo of the hp-paper, this would // be the simple case. note that we can short-circuit this // decision if the dof_handler doesn't support hp at all // @@ -1142,7 +1142,7 @@ namespace DoFTools case FiniteElementDomination::either_element_can_dominate: { // Case 1 (the simple case and the only case that can - // happen for non-hp DoFHandlers): The coarse element + // happen for non-hp-DoFHandlers): The coarse element // dominates the elements on the subfaces (or they are // all the same) // @@ -1255,10 +1255,10 @@ namespace DoFTools { // Case 2 (the "complex" case): at least one (the // neither_... case) of the finer elements or all of - // them (the other_... case) is dominating. See the hp + // them (the other_... case) is dominating. See the hp- // paper for a way how to deal with this situation // - // since this is something that can only happen for hp + // since this is something that can only happen for hp- // dof handlers, add a check here... Assert(dof_handler.has_hp_capabilities() == true, ExcInternalError()); @@ -1389,7 +1389,7 @@ namespace DoFTools // next we have to deal with the subfaces. do as - // discussed in the hp paper + // discussed in the hp-paper for (unsigned int sf = 0; sf < cell->face(face)->n_children(); ++sf) @@ -1581,7 +1581,7 @@ namespace DoFTools // our best bet is to find the common space among // other FEs in FECollection and then constrain both // FEs to that one. More precisely, we follow the - // strategy outlined on page 17 of the hp paper: + // strategy outlined on page 17 of the hp-paper: // First we find the dominant FE space S. Then we // divide our dofs in primary and dependent such // that I^{face,primary}_{S^{face}->S} is @@ -3156,7 +3156,7 @@ namespace DoFTools Assert(coarse_grid.get_fe_collection().size() == 1 && fine_grid.get_fe_collection().size() == 1, ExcMessage("This function is not yet implemented for DoFHandlers " - "using hp capabilities.")); + "using hp-capabilities.")); // store the weights with which a dof on the parameter grid contributes to a // dof on the fine grid. see the long doc below for more info // @@ -3340,7 +3340,7 @@ namespace DoFTools Assert(coarse_grid.get_fe_collection().size() == 1 && fine_grid.get_fe_collection().size() == 1, ExcMessage("This function is not yet implemented for DoFHandlers " - "using hp capabilities.")); + "using hp-capabilities.")); // store the weights with which a dof on the parameter grid contributes to a // dof on the fine grid. see the long doc below for more info // diff --git a/source/dofs/dof_tools_sparsity.cc b/source/dofs/dof_tools_sparsity.cc index 82b91388c5..241e1e6746 100644 --- a/source/dofs/dof_tools_sparsity.cc +++ b/source/dofs/dof_tools_sparsity.cc @@ -765,7 +765,7 @@ namespace DoFTools namespace { // implementation of the same function in namespace DoFTools for - // non-hp DoFHandlers + // non-hp-DoFHandlers template is_active() && neighbor->is_locally_owned()) continue; - // Again, like the non-hp case: If we are more refined + // Again, like the non-hp-case: If we are more refined // then the neighbor, then we will automatically find // the active neighbor cell when we call 'neighbor // (face)' above. The opposite is not true; if the diff --git a/source/fe/fe_bernstein.cc b/source/fe/fe_bernstein.cc index 07e2aa9db9..ee1c0f1a69 100644 --- a/source/fe/fe_bernstein.cc +++ b/source/fe/fe_bernstein.cc @@ -131,7 +131,7 @@ FE_Bernstein::get_subface_interpolation_matrix( // Make sure that the element for which the DoFs should be constrained // is the one with the higher polynomial degree. Actually the procedure // will work also if this assertion is not satisfied. But the matrices - // produced in that case might lead to problems in the hp procedures, + // produced in that case might lead to problems in the hp-procedures, // which use this method. Assert( this->n_dofs_per_face(face_no) <= source_fe->n_dofs_per_face(face_no), diff --git a/source/fe/fe_face.cc b/source/fe/fe_face.cc index d673916566..0e78e47ddc 100644 --- a/source/fe/fe_face.cc +++ b/source/fe/fe_face.cc @@ -181,7 +181,7 @@ FE_FaceQ::get_subface_interpolation_matrix( // Make sure that the element for which the DoFs should be constrained // is the one with the higher polynomial degree. Actually the procedure // will work also if this assertion is not satisfied. But the matrices - // produced in that case might lead to problems in the hp procedures, + // produced in that case might lead to problems in the hp-procedures, // which use this method. Assert( this->n_dofs_per_face(face_no) <= source_fe->n_dofs_per_face(face_no), @@ -910,7 +910,7 @@ FE_FaceP::get_subface_interpolation_matrix( // Make sure that the element for which the DoFs should be constrained // is the one with the higher polynomial degree. Actually the procedure // will work also if this assertion is not satisfied. But the matrices - // produced in that case might lead to problems in the hp procedures, + // produced in that case might lead to problems in the hp-procedures, // which use this method. Assert( this->n_dofs_per_face(face_no) <= source_fe->n_dofs_per_face(face_no), diff --git a/source/fe/fe_nedelec.cc b/source/fe/fe_nedelec.cc index caa4f1f39d..56974a0d9b 100644 --- a/source/fe/fe_nedelec.cc +++ b/source/fe/fe_nedelec.cc @@ -2500,7 +2500,7 @@ FE_Nedelec::get_face_interpolation_matrix( // satisfied. But the matrices // produced in that case might // lead to problems in the - // hp procedures, which use this + // hp-procedures, which use this // method. Assert(this->n_dofs_per_face(face_no) <= source_fe.n_dofs_per_face(face_no), (typename FiniteElement::ExcInterpolationNotImplemented())); @@ -2607,7 +2607,7 @@ FE_Nedelec::get_subface_interpolation_matrix( // satisfied. But the matrices // produced in that case might // lead to problems in the - // hp procedures, which use this + // hp-procedures, which use this // method. Assert(this->n_dofs_per_face(face_no) <= source_fe.n_dofs_per_face(face_no), (typename FiniteElement::ExcInterpolationNotImplemented())); diff --git a/source/fe/fe_q_base.cc b/source/fe/fe_q_base.cc index 3d6cf65dd4..9f444f7aa0 100644 --- a/source/fe/fe_q_base.cc +++ b/source/fe/fe_q_base.cc @@ -644,7 +644,7 @@ FE_Q_Base::get_subface_interpolation_matrix( // Make sure that the element for which the DoFs should be constrained // is the one with the higher polynomial degree. Actually the procedure // will work also if this assertion is not satisfied. But the matrices - // produced in that case might lead to problems in the hp procedures, + // produced in that case might lead to problems in the hp-procedures, // which use this method. Assert( this->n_dofs_per_face(face_no) <= source_fe->n_dofs_per_face(face_no), diff --git a/source/fe/fe_q_hierarchical.cc b/source/fe/fe_q_hierarchical.cc index 670ec26d5e..71296683df 100644 --- a/source/fe/fe_q_hierarchical.cc +++ b/source/fe/fe_q_hierarchical.cc @@ -965,7 +965,7 @@ FE_Q_Hierarchical::get_face_interpolation_matrix( // satisfied. But the matrices // produced in that case might // lead to problems in the - // hp procedures, which use this + // hp-procedures, which use this // method. Assert(this->n_dofs_per_face(face_no) <= source_fe.n_dofs_per_face(face_no), (typename FiniteElement::ExcInterpolationNotImplemented())); @@ -1053,7 +1053,7 @@ FE_Q_Hierarchical::get_subface_interpolation_matrix( // satisfied. But the matrices // produced in that case might // lead to problems in the - // hp procedures, which use this + // hp-procedures, which use this // method. Assert(this->n_dofs_per_face(face_no) <= source_fe.n_dofs_per_face(face_no), (typename FiniteElement::ExcInterpolationNotImplemented())); diff --git a/source/fe/fe_raviart_thomas_nodal.cc b/source/fe/fe_raviart_thomas_nodal.cc index 4ca716558b..e43c7c0bd0 100644 --- a/source/fe/fe_raviart_thomas_nodal.cc +++ b/source/fe/fe_raviart_thomas_nodal.cc @@ -378,7 +378,7 @@ FE_RaviartThomasNodal:: // TODO: There are tests that check that the following few functions don't // produce assertion failures, but none that actually check whether they do the // right thing. one example for such a test would be to project a function onto -// an hp space and make sure that the convergence order is correct with regard +// an hp-space and make sure that the convergence order is correct with regard // to the lowest used polynomial degree template @@ -625,7 +625,7 @@ FE_RaviartThomasNodal::get_face_interpolation_matrix( // satisfied. But the matrices // produced in that case might // lead to problems in the - // hp procedures, which use this + // hp-procedures, which use this // method. Assert(this->n_dofs_per_face(face_no) <= source_fe.n_dofs_per_face(face_no), typename FiniteElement::ExcInterpolationNotImplemented()); @@ -733,7 +733,7 @@ FE_RaviartThomasNodal::get_subface_interpolation_matrix( // satisfied. But the matrices // produced in that case might // lead to problems in the - // hp procedures, which use this + // hp-procedures, which use this // method. Assert(this->n_dofs_per_face(face_no) <= source_fe.n_dofs_per_face(face_no), typename FiniteElement::ExcInterpolationNotImplemented()); diff --git a/source/hp/refinement.cc b/source/hp/refinement.cc index dbe8ae5485..3a2c80e6e0 100644 --- a/source/hp/refinement.cc +++ b/source/hp/refinement.cc @@ -37,7 +37,7 @@ namespace hp namespace Refinement { /** - * Setting p adaptivity flags + * Setting p-adaptivity flags */ template void @@ -631,7 +631,7 @@ namespace hp /** - * Decide between h and p adaptivity + * Decide between h- and p-adaptivity */ template void @@ -695,9 +695,9 @@ namespace hp cell->clear_refine_flag(); // A cell will only be coarsened into its parent if all of its - // siblings are flagged for h coarsening as well. We must take this - // into account for our decision whether we would like to impose h - // or p adaptivity. + // siblings are flagged for h-coarsening as well. We must take this + // into account for our decision whether we would like to impose h- + // or p-adaptivity. if (cell->coarsen_flag_set()) { const auto & parent = cell->parent(); @@ -737,8 +737,8 @@ namespace hp if (h_flagged_children == n_children && p_flagged_children != n_children) { - // Perform pure h coarsening and - // drop all p adaptation flags. + // Perform pure h-coarsening and + // drop all p-adaptation flags. for (const auto &child : parent->child_iterators()) { // h_flagged_children == n_children implies @@ -750,8 +750,8 @@ namespace hp } else { - // Perform p adaptation on all children and - // drop all h coarsening flags. + // Perform p-adaptation on all children and + // drop all h-coarsening flags. for (const auto &child : parent->child_iterators()) { if (child->is_active() && child->is_locally_owned()) diff --git a/source/matrix_free/task_info.cc b/source/matrix_free/task_info.cc index dcf1c19497..9ab41f175b 100644 --- a/source/matrix_free/task_info.cc +++ b/source/matrix_free/task_info.cc @@ -798,7 +798,7 @@ namespace internal // a. Only cells belonging to the same category (or next higher if the // cell_vectorization_categories_strict is false) can be grouped into // the same SIMD batch - // b. hp adaptive computations must form contiguous ranges for the same + // b. hp-adaptive computations must form contiguous ranges for the same // degree (category) in cell_partition_data // c. We want to group the cells with the same parent in the same SIMD // lane if possible @@ -954,7 +954,7 @@ namespace internal // Step 5: Sort the batches of cells by their last cell index to get // good locality, assuming that the initial cell order is of good - // locality. In case we have hp calculations with categories, we need to + // locality. In case we have hp-calculations with categories, we need to // sort also by the category. std::vector> batch_order; std::vector> batch_order_comm; diff --git a/source/numerics/data_out_stack.cc b/source/numerics/data_out_stack.cc index c2daf74cac..b809d99a2c 100644 --- a/source/numerics/data_out_stack.cc +++ b/source/numerics/data_out_stack.cc @@ -287,7 +287,7 @@ DataOutStack::build_patches( // create collection objects from // single quadratures, // and finite elements. if we have - // an hp DoFHandler, + // an hp-DoFHandler, // dof_handler.get_fe() returns a // collection of which we do a // shallow copy instead diff --git a/source/numerics/derivative_approximation.cc b/source/numerics/derivative_approximation.cc index 38ad27d01b..32822082ef 100644 --- a/source/numerics/derivative_approximation.cc +++ b/source/numerics/derivative_approximation.cc @@ -752,7 +752,7 @@ namespace DerivativeApproximation // create collection objects from // single quadratures, mappings, // and finite elements. if we have - // an hp DoFHandler, + // an hp-DoFHandler, // dof_handler.get_fe() returns a // collection of which we do a // shallow copy instead diff --git a/source/numerics/matrix_creator.inst.in b/source/numerics/matrix_creator.inst.in index 38d737ea6d..3d8d8a978e 100644 --- a/source/numerics/matrix_creator.inst.in +++ b/source/numerics/matrix_creator.inst.in @@ -21,7 +21,7 @@ for (scalar : REAL_SCALARS; deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) { #if deal_II_dimension <= deal_II_space_dimension - // non-hp version of create_mass_matrix + // non-hp-version of create_mass_matrix template void MatrixCreator:: create_mass_matrix( const Mapping & mapping, @@ -38,7 +38,7 @@ for (scalar : REAL_SCALARS; deal_II_dimension : DIMENSIONS; const Function *const coefficient, const AffineConstraints & constraints); - // hp versions of functions + // hp-versions of functions template void MatrixCreator:: create_mass_matrix( const hp::MappingCollection @@ -66,7 +66,7 @@ for (scalar : REAL_AND_COMPLEX_SCALARS; deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) { #if deal_II_dimension <= deal_II_space_dimension - // non-hp version of create_mass_matrix + // non-hp-version of create_mass_matrix template void MatrixCreator:: create_mass_matrix( const Mapping & mapping, @@ -87,7 +87,7 @@ for (scalar : REAL_AND_COMPLEX_SCALARS; deal_II_dimension : DIMENSIONS; const Function *const coefficient, const AffineConstraints & constraints); - // hp version + // hp-version template void MatrixCreator:: create_mass_matrix( const hp::MappingCollection @@ -183,7 +183,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) { #if deal_II_dimension == deal_II_space_dimension - // non-hp versions of create_laplace_matrix + // non-hp-versions of create_laplace_matrix template void MatrixCreator::create_laplace_matrix( const DoFHandler & dof, const Quadrature & q, @@ -215,7 +215,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) const Function *const coefficient, const AffineConstraints & constraints); - // hp versions of create_laplace_matrix + // hp-versions of create_laplace_matrix template void MatrixCreator::create_laplace_matrix( const DoFHandler & dof, const hp::QCollection &q, @@ -253,7 +253,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) { #if deal_II_dimension < deal_II_space_dimension - // non-hp version of create_laplace_matrix + // non-hp-version of create_laplace_matrix template void MatrixCreator::create_laplace_matrix( const Mapping & mapping, diff --git a/source/numerics/solution_transfer.cc b/source/numerics/solution_transfer.cc index 150af1711a..1d6b1d147f 100644 --- a/source/numerics/solution_transfer.cc +++ b/source/numerics/solution_transfer.cc @@ -351,9 +351,9 @@ SolutionTransfer:: else if (cell->has_children() && cell->child(0)->coarsen_flag_set()) { // we will need to interpolate from the children of this cell - // to the current one. in the hp context, this also means + // to the current one. in the hp-context, this also means // we need to figure out which finite element space to interpolate - // to since that is not implied by the global FE as in the non-hp + // to since that is not implied by the global FE as in the non-hp- // case. we choose the 'least dominant fe' on all children from // the associated FECollection. std::set fe_indices_children; @@ -505,7 +505,7 @@ SolutionTransfer::interpolate( { // make sure that the size of the stored indices is the same // as dofs_per_cell. this is kind of a test if we use the same - // fe in the hp case. to really do that test we would have to + // fe in the hp-case. to really do that test we would have to // store the fe_index of all cells const Vector *data = nullptr; const unsigned int active_fe_index = cell->active_fe_index(); diff --git a/tests/aniso/hp_constraints_dgp_08.cc b/tests/aniso/hp_constraints_dgp_08.cc index f6c20b2106..d75217d6b0 100644 --- a/tests/aniso/hp_constraints_dgp_08.cc +++ b/tests/aniso/hp_constraints_dgp_08.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for DGP elements correctly +// check that computation of hp-constraints works for DGP elements correctly char logname[] = "output"; diff --git a/tests/aniso/hp_constraints_dgp_monomial_08.cc b/tests/aniso/hp_constraints_dgp_monomial_08.cc index dc53e291b5..84d884aaf6 100644 --- a/tests/aniso/hp_constraints_dgp_monomial_08.cc +++ b/tests/aniso/hp_constraints_dgp_monomial_08.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for DGP_Monomial elements +// check that computation of hp-constraints works for DGP_Monomial elements // correctly char logname[] = "output"; diff --git a/tests/aniso/hp_constraints_dgp_nonparametric_08.cc b/tests/aniso/hp_constraints_dgp_nonparametric_08.cc index 308b24f863..acad818e98 100644 --- a/tests/aniso/hp_constraints_dgp_nonparametric_08.cc +++ b/tests/aniso/hp_constraints_dgp_nonparametric_08.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for DGPNonparametric elements +// check that computation of hp-constraints works for DGPNonparametric elements // correctly on a uniformly refined mesh for functions of degree q char logname[] = "output"; diff --git a/tests/aniso/hp_constraints_dgq_08.cc b/tests/aniso/hp_constraints_dgq_08.cc index f55d954693..f27a596e7e 100644 --- a/tests/aniso/hp_constraints_dgq_08.cc +++ b/tests/aniso/hp_constraints_dgq_08.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for DGQ elements correctly +// check that computation of hp-constraints works for DGQ elements correctly char logname[] = "output"; diff --git a/tests/bits/count_dofs_per_component_hp_01.cc b/tests/bits/count_dofs_per_component_hp_01.cc index 4eab486a8f..65d5fbb3de 100644 --- a/tests/bits/count_dofs_per_component_hp_01.cc +++ b/tests/bits/count_dofs_per_component_hp_01.cc @@ -28,7 +28,7 @@ // check // DoFTools:: // count_dofs_per_component (...); -// for the hp case +// for the hp-case using namespace std; diff --git a/tests/bits/count_dofs_per_component_hp_02.cc b/tests/bits/count_dofs_per_component_hp_02.cc index c133fc7900..8cf3ac5280 100644 --- a/tests/bits/count_dofs_per_component_hp_02.cc +++ b/tests/bits/count_dofs_per_component_hp_02.cc @@ -32,7 +32,7 @@ // check // DoFTools:: // count_dofs_per_component (...); -// for the hp case +// for the hp-case // // in contrast to the _01 test also check that this works if the element // collection has more than one element diff --git a/tests/bits/face_orientation_crash.cc b/tests/bits/face_orientation_crash.cc index fafdcbd0c2..08e7b32286 100644 --- a/tests/bits/face_orientation_crash.cc +++ b/tests/bits/face_orientation_crash.cc @@ -73,7 +73,7 @@ check() // then build hanging node // constraints. this should trip the - // new code using the hp constraints, + // new code using the hp-constraints, // added in late July 2006 AffineConstraints constraints; DoFTools::make_hanging_node_constraints(dof, constraints); diff --git a/tests/bits/map_dofs_to_support_points_hp_01.cc b/tests/bits/map_dofs_to_support_points_hp_01.cc index e18ef5f364..df66b6a37f 100644 --- a/tests/bits/map_dofs_to_support_points_hp_01.cc +++ b/tests/bits/map_dofs_to_support_points_hp_01.cc @@ -31,7 +31,7 @@ // check // DoFTools:: // map_dofs_to_support_points(...); -// for the hp case +// for the hp-case using namespace std; diff --git a/tests/bits/map_dofs_to_support_points_hp_02.cc b/tests/bits/map_dofs_to_support_points_hp_02.cc index 220a73b39f..fde7dd63d6 100644 --- a/tests/bits/map_dofs_to_support_points_hp_02.cc +++ b/tests/bits/map_dofs_to_support_points_hp_02.cc @@ -32,7 +32,7 @@ // check // DoFTools:: // map_dofs_to_support_points(...); -// for the hp case with different finite elements +// for the hp-case with different finite elements // on different cells. diff --git a/tests/bits/point_gradient_hp_01.cc b/tests/bits/point_gradient_hp_01.cc index e1b6431de5..65950a26bc 100644 --- a/tests/bits/point_gradient_hp_01.cc +++ b/tests/bits/point_gradient_hp_01.cc @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- -// check VectorTools::point_gradient for a hp dofhandler. +// check VectorTools::point_gradient for a hp-dofhandler. diff --git a/tests/bits/point_value_hp_01.cc b/tests/bits/point_value_hp_01.cc index 43705d0712..042296f8e5 100644 --- a/tests/bits/point_value_hp_01.cc +++ b/tests/bits/point_value_hp_01.cc @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- -// check VectorTools::point_value for a hp dofhandler. +// check VectorTools::point_value for a hp-dofhandler. diff --git a/tests/fail/hp_constraints_q_08.cc b/tests/fail/hp_constraints_q_08.cc index 8793d7f52b..7d59e01c22 100644 --- a/tests/fail/hp_constraints_q_08.cc +++ b/tests/fail/hp_constraints_q_08.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for Q elements correctly +// check that computation of hp-constraints works for Q elements correctly char logname[] = "output"; diff --git a/tests/fail/hp_constraints_q_system_08.cc b/tests/fail/hp_constraints_q_system_08.cc index 25485a1d19..999e70812c 100644 --- a/tests/fail/hp_constraints_q_system_08.cc +++ b/tests/fail/hp_constraints_q_system_08.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for FESystem(FE_Q) elements +// check that computation of hp-constraints works for FESystem(FE_Q) elements // correctly on a uniformly refined mesh for functions of degree q char logname[] = "output"; diff --git a/tests/fail/hp_constraints_q_system_x_08.cc b/tests/fail/hp_constraints_q_system_x_08.cc index f6f0882c57..5d6ae317b8 100644 --- a/tests/fail/hp_constraints_q_system_x_08.cc +++ b/tests/fail/hp_constraints_q_system_x_08.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for FESystem(FE_Q) elements +// check that computation of hp-constraints works for FESystem(FE_Q) elements // correctly on a uniformly refined mesh for functions of degree q // these tests check that we can deal with FESystem(FE_Q(p),FE_DGQ(q)) for diff --git a/tests/fail/hp_constraints_rt_01.cc b/tests/fail/hp_constraints_rt_01.cc index 7459fcfbe7..d002b8e535 100644 --- a/tests/fail/hp_constraints_rt_01.cc +++ b/tests/fail/hp_constraints_rt_01.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for RT elements correctly +// check that computation of hp-constraints works for RT elements correctly char logname[] = "output"; diff --git a/tests/fail/hp_constraints_rt_02.cc b/tests/fail/hp_constraints_rt_02.cc index 2d939b5961..75659e8ac3 100644 --- a/tests/fail/hp_constraints_rt_02.cc +++ b/tests/fail/hp_constraints_rt_02.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for RT elements correctly +// check that computation of hp-constraints works for RT elements correctly char logname[] = "output"; diff --git a/tests/fail/hp_constraints_rt_03.cc b/tests/fail/hp_constraints_rt_03.cc index 53aada348f..0a784e881a 100644 --- a/tests/fail/hp_constraints_rt_03.cc +++ b/tests/fail/hp_constraints_rt_03.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for RT elements correctly +// check that computation of hp-constraints works for RT elements correctly char logname[] = "output"; diff --git a/tests/fail/hp_constraints_rt_04.cc b/tests/fail/hp_constraints_rt_04.cc index da81338735..be480a3bf5 100644 --- a/tests/fail/hp_constraints_rt_04.cc +++ b/tests/fail/hp_constraints_rt_04.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for RT elements correctly +// check that computation of hp-constraints works for RT elements correctly char logname[] = "output"; diff --git a/tests/fail/hp_constraints_rt_05.cc b/tests/fail/hp_constraints_rt_05.cc index 1a5b076587..d4f1da74aa 100644 --- a/tests/fail/hp_constraints_rt_05.cc +++ b/tests/fail/hp_constraints_rt_05.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for RT elements correctly +// check that computation of hp-constraints works for RT elements correctly char logname[] = "output"; diff --git a/tests/fail/hp_constraints_rt_06.cc b/tests/fail/hp_constraints_rt_06.cc index 1c2e6c0629..23f9bb83ca 100644 --- a/tests/fail/hp_constraints_rt_06.cc +++ b/tests/fail/hp_constraints_rt_06.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for RT elements correctly +// check that computation of hp-constraints works for RT elements correctly char logname[] = "output"; diff --git a/tests/fail/vectors_boundary_rhs_hp_02.cc b/tests/fail/vectors_boundary_rhs_hp_02.cc index f1397b0012..508302c256 100644 --- a/tests/fail/vectors_boundary_rhs_hp_02.cc +++ b/tests/fail/vectors_boundary_rhs_hp_02.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_boundary_rhs_02, but for hp objects. here, each hp +// like deal.II/vectors_boundary_rhs_02, but for hp-objects. here, each hp- // object has only a single component, so we expect exactly the same output as // for the old test. vectors_boundary_rhs_hp_02_hp tests for different finite // elements diff --git a/tests/fail/vectors_rhs_hp_02.cc b/tests/fail/vectors_rhs_hp_02.cc index 620df0fa1b..77f8c327fa 100644 --- a/tests/fail/vectors_rhs_hp_02.cc +++ b/tests/fail/vectors_rhs_hp_02.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_rhs_hp_02, but for hp objects. here, each hp object has +// like deal.II/vectors_rhs_hp_02, but for hp-objects. here, each hp-object has // only a single component, so we expect exactly the same output as for the old // test. vectors_rhs_hp_02_hp tests for different finite elements diff --git a/tests/fe/fe_enriched_07.cc b/tests/fe/fe_enriched_07.cc index 1081be2273..278d262b94 100644 --- a/tests/fe/fe_enriched_07.cc +++ b/tests/fe/fe_enriched_07.cc @@ -96,7 +96,7 @@ test6(const bool do_href, fe_collection.push_back(FE_Enriched(FE_Q(p_feq))); fe_collection.push_back( FE_Enriched(FE_Q(p_feen), FE_Q(1), &function)); - // push back to be able to resolve hp constrains: + // push back to be able to resolve hp-constrains: fe_collection.push_back(FE_Enriched(FE_Q(p_feen))); GridGenerator::hyper_cube(triangulation); diff --git a/tests/fe/fe_enriched_08.cc b/tests/fe/fe_enriched_08.cc index fd0e56bbdf..2f0d81466e 100644 --- a/tests/fe/fe_enriched_08.cc +++ b/tests/fe/fe_enriched_08.cc @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- -// check constraints on hp dofhandler with 2 neighboring cells where one +// check constraints on hp-dofhandler with 2 neighboring cells where one // cell is enriched and nother is not. #include @@ -110,7 +110,7 @@ test2cells(const unsigned int p_feq = 2, const unsigned int p_feen = 1) fe_collection.push_back(FE_Enriched(FE_Q(p_feq))); fe_collection.push_back( FE_Enriched(FE_Q(p_feen), FE_Q(1), &function)); - // push back to be able to resolve hp constrains: + // push back to be able to resolve hp-constrains: fe_collection.push_back(FE_Enriched(FE_Q(p_feen))); dof_handler.begin_active()->set_active_fe_index(1); // POU diff --git a/tests/fe/fe_enriched_08a.cc b/tests/fe/fe_enriched_08a.cc index 0d4ce7c5ee..39d00e2da4 100644 --- a/tests/fe/fe_enriched_08a.cc +++ b/tests/fe/fe_enriched_08a.cc @@ -77,7 +77,7 @@ test2cellsFESystem(const unsigned int p_feq = 2, const unsigned int p_feen = 1) FESystem(FE_Q(p_feq), 1, FE_Nothing(), 1)); fe_collection.push_back(FESystem(FE_Q(p_feen), 1, FE_Q(1), 1)); - // push back to be able to resolve hp constrains: + // push back to be able to resolve hp-constrains: fe_collection.push_back( FESystem(FE_Q(p_feen), 1, FE_Nothing(), 1)); diff --git a/tests/grid/mesh_3d_18.cc b/tests/grid/mesh_3d_18.cc index d1c8b295dd..76c2b6bd59 100644 --- a/tests/grid/mesh_3d_18.cc +++ b/tests/grid/mesh_3d_18.cc @@ -16,7 +16,7 @@ // adapted from hp/crash_06, which itself is from -// make_hanging_node_constraints for hp elements. used to crash. triggers the +// make_hanging_node_constraints for hp-elements. used to crash. triggers the // crash that at the time of writing the test afflicts all // hp/hp_constraints_*_03 tests diff --git a/tests/grid/vertex_as_face_07.cc b/tests/grid/vertex_as_face_07.cc index d6422abe6f..aec3695e29 100644 --- a/tests/grid/vertex_as_face_07.cc +++ b/tests/grid/vertex_as_face_07.cc @@ -16,7 +16,7 @@ // verify that we can do things like cell->face() in 1d as well. here: // test cell->face(0)->get_dof_indices() -// compared to _06, we now test for an hp DoFHandler +// compared to _06, we now test for an hp-DoFHandler #include #include diff --git a/tests/hp/boundary_matrices.cc b/tests/hp/boundary_matrices.cc index 7a131963db..c8e08f8583 100644 --- a/tests/hp/boundary_matrices.cc +++ b/tests/hp/boundary_matrices.cc @@ -16,7 +16,7 @@ // Like hp/matrices, but only the boundary mass matrices for vector-valued -// (non-primitive) hp objects are being tested. +// (non-primitive) hp-objects are being tested. #include diff --git a/tests/hp/boundary_matrices_hp.cc b/tests/hp/boundary_matrices_hp.cc index 8aa54ca331..0a0d37437d 100644 --- a/tests/hp/boundary_matrices_hp.cc +++ b/tests/hp/boundary_matrices_hp.cc @@ -16,7 +16,7 @@ // Same as hp/boundary_matrices, but with different FE objects. Tests -// the boundary mass matrces for vector-valued (non-primiteve) hp +// the boundary mass matrces for vector-valued (non-primiteve) hp- // FE objects. diff --git a/tests/hp/compare_hp_vs_nonhp_01.cc b/tests/hp/compare_hp_vs_nonhp_01.cc index 730f0e29cf..d9edda2d76 100644 --- a/tests/hp/compare_hp_vs_nonhp_01.cc +++ b/tests/hp/compare_hp_vs_nonhp_01.cc @@ -16,7 +16,7 @@ // a test adapted from little programs by Markus Buerg that makes sure -// we compute the same solution for hp and non-hp cases +// we compute the same solution for hp- and non-hp-cases #include diff --git a/tests/hp/crash_08.cc b/tests/hp/crash_08.cc index 776b5de659..d3241cdc4f 100644 --- a/tests/hp/crash_08.cc +++ b/tests/hp/crash_08.cc @@ -15,7 +15,7 @@ -// the crash_08 testcase discussed in the hp paper. this produces a cyclic +// the crash_08 testcase discussed in the hp-paper. this produces a cyclic // constraint between degrees of freedom 3->14->17->6->3 with the algorithm // that is presently in make_hanging_node_constraints diff --git a/tests/hp/crash_09.cc b/tests/hp/crash_09.cc index 6563bb6c6e..e114c77ec5 100644 --- a/tests/hp/crash_09.cc +++ b/tests/hp/crash_09.cc @@ -16,7 +16,7 @@ // a test where a degree of freedom was constrained multiple times, -// but with different weights. see the hp paper for more on this +// but with different weights. see the hp-paper for more on this char logname[] = "output"; diff --git a/tests/hp/crash_11.cc b/tests/hp/crash_11.cc index 2def2b0634..afc1f7f643 100644 --- a/tests/hp/crash_11.cc +++ b/tests/hp/crash_11.cc @@ -16,7 +16,7 @@ // a test where a degree of freedom was constrained multiple times, -// but with different weights. see the hp paper for more on this +// but with different weights. see the hp-paper for more on this #include #include diff --git a/tests/hp/crash_12.cc b/tests/hp/crash_12.cc index 82b0b794ea..5d2ce3fd68 100644 --- a/tests/hp/crash_12.cc +++ b/tests/hp/crash_12.cc @@ -15,7 +15,7 @@ -// check the complex case described in the hp paper by playing through all +// check the complex case described in the hp-paper by playing through all // sorts of arrangements of finite elements on one coarse and one refined cell // // this code in particular tests some compensating code in diff --git a/tests/hp/crash_15.cc b/tests/hp/crash_15.cc index 42e5775022..8c9443bd0c 100644 --- a/tests/hp/crash_15.cc +++ b/tests/hp/crash_15.cc @@ -22,7 +22,7 @@ // apparently, what is happening is that we don't unify more than 2 finite // elements on an edge in 3d, according to a comment at the top of // hp::DoFHandler::compute_line_dof_identities at the time of this writing -// (and referring to a comment in the hp paper). there is now code that deals +// (and referring to a comment in the hp-paper). there is now code that deals // with the more narrow special case we have here #include diff --git a/tests/hp/crash_21.cc b/tests/hp/crash_21.cc index 0949de23bb..4d2421a8e8 100644 --- a/tests/hp/crash_21.cc +++ b/tests/hp/crash_21.cc @@ -17,7 +17,7 @@ // a problem uncovered by Baerbel Janssen in that // DoFTools::make_flux_sparsity_pattern aborted in 1d with adaptively refined -// meshes and hp DoFHandlers. this actually uncovered all sorts of other +// meshes and hp-DoFHandlers. this actually uncovered all sorts of other // problems that led to a long sequence of assertions triggered every time one // of them was fixed. this test cumulatively makes sure everything is ok diff --git a/tests/hp/dof_handler_number_cache.cc b/tests/hp/dof_handler_number_cache.cc index cf3951f06b..254381e25e 100644 --- a/tests/hp/dof_handler_number_cache.cc +++ b/tests/hp/dof_handler_number_cache.cc @@ -16,7 +16,7 @@ // Check the consistency of the number cache of DoFHandler for a sequential -// object. Like deal.II/dof_handler_number_cache but for an hp object +// object. Like deal.II/dof_handler_number_cache but for an hp-object #include diff --git a/tests/hp/error_prediction_01.cc b/tests/hp/error_prediction_01.cc index 8b1f60d683..e3a8a50c0b 100644 --- a/tests/hp/error_prediction_01.cc +++ b/tests/hp/error_prediction_01.cc @@ -16,7 +16,7 @@ // validate combination of error prediction and cell data transfer algorithms -// for hp adaptive methods +// for hp-adaptive methods #include diff --git a/tests/hp/fe_nothing_11.cc b/tests/hp/fe_nothing_11.cc index aed473a60c..22d1af8a3e 100644 --- a/tests/hp/fe_nothing_11.cc +++ b/tests/hp/fe_nothing_11.cc @@ -16,7 +16,7 @@ // test that FE_Nothing can be called with interpolate_boundary_values -// with vector elements in the hp context with each element active +// with vector elements in the hp-context with each element active // only in a subdomain diff --git a/tests/hp/fe_nothing_20.cc b/tests/hp/fe_nothing_20.cc index 61d5307a4f..f52f901e6d 100644 --- a/tests/hp/fe_nothing_20.cc +++ b/tests/hp/fe_nothing_20.cc @@ -15,7 +15,7 @@ -// interpolate() can not deal with FE_Nothing in an hp setting +// interpolate() can not deal with FE_Nothing in an hp-setting #include diff --git a/tests/hp/flux_sparsity.cc b/tests/hp/flux_sparsity.cc index a93bd3ca30..a100d69a99 100644 --- a/tests/hp/flux_sparsity.cc +++ b/tests/hp/flux_sparsity.cc @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- // A test that checks make_flux_sparsity_pattern -// with vector-valued hp objects and coupling masks +// with vector-valued hp-objects and coupling masks #include #include diff --git a/tests/hp/flux_sparsity_02.cc b/tests/hp/flux_sparsity_02.cc index 34b72209d8..fb2e313d2f 100644 --- a/tests/hp/flux_sparsity_02.cc +++ b/tests/hp/flux_sparsity_02.cc @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- // A second test that checks make_flux_sparsity_pattern -// with scalar valued hp objects. +// with scalar valued hp-objects. #include #include diff --git a/tests/hp/get_interpolated_dof_values_01.cc b/tests/hp/get_interpolated_dof_values_01.cc index 731787e643..fb5d7b9881 100644 --- a/tests/hp/get_interpolated_dof_values_01.cc +++ b/tests/hp/get_interpolated_dof_values_01.cc @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- -// cell->get_interpolated_dof_values can not work properly in the hp +// cell->get_interpolated_dof_values can not work properly in the hp- // context when called on non-active cells because these do not have a // finite element associated with them diff --git a/tests/hp/get_interpolated_dof_values_02.cc b/tests/hp/get_interpolated_dof_values_02.cc index 917b290935..b641b2520a 100644 --- a/tests/hp/get_interpolated_dof_values_02.cc +++ b/tests/hp/get_interpolated_dof_values_02.cc @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- -// cell->get_interpolated_dof_values can not work properly in the hp +// cell->get_interpolated_dof_values can not work properly in the hp- // context when called on non-active cells because these do not have a // finite element associated with them // diff --git a/tests/hp/get_interpolated_dof_values_03.cc b/tests/hp/get_interpolated_dof_values_03.cc index 302d645ba1..ffd75e276a 100644 --- a/tests/hp/get_interpolated_dof_values_03.cc +++ b/tests/hp/get_interpolated_dof_values_03.cc @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- -// cell->get_interpolated_dof_values can not work properly in the hp +// cell->get_interpolated_dof_values can not work properly in the hp- // context when called on non-active cells because these do not have a // finite element associated with them // diff --git a/tests/hp/hp_coarsening.cc b/tests/hp/hp_coarsening.cc index ebe169ec89..3b8d8c4ae3 100644 --- a/tests/hp/hp_coarsening.cc +++ b/tests/hp/hp_coarsening.cc @@ -15,8 +15,8 @@ -// validate hp decision algorithms on grid coarsening -// that depend on the composition of h and p adaptivity flags +// validate hp-decision algorithms on grid coarsening +// that depend on the composition of h- and p-adaptivity flags #include @@ -53,7 +53,7 @@ setup(Triangulation &tria, const DoFHandler &dh) GridGenerator::hyper_cube(tria); tria.refine_global(1); - // Set h and p flags on all cells. + // Set h- and p-flags on all cells. for (const auto &cell : dh.active_cell_iterators()) { cell->set_coarsen_flag(); diff --git a/tests/hp/hp_constraints_b.cc b/tests/hp/hp_constraints_b.cc index 14040cf22f..1776ab7990 100644 --- a/tests/hp/hp_constraints_b.cc +++ b/tests/hp/hp_constraints_b.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for Bernstein elements +// check that computation of hp-constraints works for Bernstein elements // correctly char logname[] = "output"; diff --git a/tests/hp/hp_constraints_common.h b/tests/hp/hp_constraints_common.h index 502ff6fcdc..10918f767c 100644 --- a/tests/hp/hp_constraints_common.h +++ b/tests/hp/hp_constraints_common.h @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- -// common framework to check hp constraints +// common framework to check hp-constraints #include #include diff --git a/tests/hp/hp_constraints_common_no_support.h b/tests/hp/hp_constraints_common_no_support.h index cc6f3ef2d3..d94968f377 100644 --- a/tests/hp/hp_constraints_common_no_support.h +++ b/tests/hp/hp_constraints_common_no_support.h @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- -// common framework to check hp constraints for fe without support points +// common framework to check hp-constraints for fe without support points #include #include diff --git a/tests/hp/hp_constraints_dgp.cc b/tests/hp/hp_constraints_dgp.cc index f6be75c3fb..6b39e71500 100644 --- a/tests/hp/hp_constraints_dgp.cc +++ b/tests/hp/hp_constraints_dgp.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for DGP elements correctly +// check that computation of hp-constraints works for DGP elements correctly char logname[] = "output"; diff --git a/tests/hp/hp_constraints_dgp_monomial.cc b/tests/hp/hp_constraints_dgp_monomial.cc index f03673ca2e..d554ae332c 100644 --- a/tests/hp/hp_constraints_dgp_monomial.cc +++ b/tests/hp/hp_constraints_dgp_monomial.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for DGP_Monomial elements +// check that computation of hp-constraints works for DGP_Monomial elements // correctly char logname[] = "output"; diff --git a/tests/hp/hp_constraints_dgp_nonparametric.cc b/tests/hp/hp_constraints_dgp_nonparametric.cc index c239f7c526..f954070768 100644 --- a/tests/hp/hp_constraints_dgp_nonparametric.cc +++ b/tests/hp/hp_constraints_dgp_nonparametric.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for DGPNonparametric elements +// check that computation of hp-constraints works for DGPNonparametric elements // correctly on a uniformly refined mesh for functions of degree q char logname[] = "output"; diff --git a/tests/hp/hp_constraints_dgq.cc b/tests/hp/hp_constraints_dgq.cc index cb26ef5617..c4fee1efbc 100644 --- a/tests/hp/hp_constraints_dgq.cc +++ b/tests/hp/hp_constraints_dgq.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for DGQ elements correctly +// check that computation of hp-constraints works for DGQ elements correctly char logname[] = "output"; diff --git a/tests/hp/hp_constraints_neither_dominate_01.cc b/tests/hp/hp_constraints_neither_dominate_01.cc index 337ffe42c5..64a24ab06b 100644 --- a/tests/hp/hp_constraints_neither_dominate_01.cc +++ b/tests/hp/hp_constraints_neither_dominate_01.cc @@ -95,7 +95,7 @@ test2cells(const unsigned int p1 = 2, const unsigned int p2 = 1) fe_collection.push_back( FESystem(FE_Q(p1), 1, FE_Nothing(1, true), 1)); fe_collection.push_back(FESystem(FE_Q(p2), 1, FE_Q(1), 1)); - // push back to be able to resolve hp constrains no matter what: + // push back to be able to resolve hp-constrains no matter what: fe_collection.push_back( FESystem(FE_Q(p2), 1, FE_Nothing(1, true), 1)); diff --git a/tests/hp/hp_constraints_q.cc b/tests/hp/hp_constraints_q.cc index 487485c566..c5845bf5b4 100644 --- a/tests/hp/hp_constraints_q.cc +++ b/tests/hp/hp_constraints_q.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for Q elements correctly +// check that computation of hp-constraints works for Q elements correctly char logname[] = "output"; diff --git a/tests/hp/hp_constraints_q_hierarchical.cc b/tests/hp/hp_constraints_q_hierarchical.cc index 00b3f54256..e479400097 100644 --- a/tests/hp/hp_constraints_q_hierarchical.cc +++ b/tests/hp/hp_constraints_q_hierarchical.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for DGP_Monomial elements +// check that computation of hp-constraints works for DGP_Monomial elements // correctly char logname[] = "output"; diff --git a/tests/hp/hp_constraints_q_system.cc b/tests/hp/hp_constraints_q_system.cc index 99ac7dd621..1818514291 100644 --- a/tests/hp/hp_constraints_q_system.cc +++ b/tests/hp/hp_constraints_q_system.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for FESystem(FE_Q) elements +// check that computation of hp-constraints works for FESystem(FE_Q) elements // correctly on a uniformly refined mesh for functions of degree q char logname[] = "output"; diff --git a/tests/hp/hp_constraints_q_system_x.cc b/tests/hp/hp_constraints_q_system_x.cc index 3050bad559..5865bdc571 100644 --- a/tests/hp/hp_constraints_q_system_x.cc +++ b/tests/hp/hp_constraints_q_system_x.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for FESystem(FE_Q) elements +// check that computation of hp-constraints works for FESystem(FE_Q) elements // correctly on a uniformly refined mesh for functions of degree q // these tests check that we can deal with FESystem(FE_Q(p),FE_DGQ(q)) for diff --git a/tests/hp/hp_constraints_rt_nodal.cc b/tests/hp/hp_constraints_rt_nodal.cc index 2c9d55eacf..069684cac0 100644 --- a/tests/hp/hp_constraints_rt_nodal.cc +++ b/tests/hp/hp_constraints_rt_nodal.cc @@ -15,7 +15,7 @@ -// check that computation of hp constraints works for RT elements correctly +// check that computation of hp-constraints works for RT elements correctly char logname[] = "output"; diff --git a/tests/hp/hp_hanging_nodes_01.cc b/tests/hp/hp_hanging_nodes_01.cc index 893b1deb61..dad119befa 100644 --- a/tests/hp/hp_hanging_nodes_01.cc +++ b/tests/hp/hp_hanging_nodes_01.cc @@ -48,7 +48,7 @@ #include "../tests.h" -// This a test for the hp capable version of the make_hanging_node_constraints +// This a test for the hp-capable version of the make_hanging_node_constraints // method. It uses a triangulation with one refined element beside an // unrefined element to create the constraints for this configuration. diff --git a/tests/hp/laplace.h b/tests/hp/laplace.h index b28991d116..cf81f70a3c 100644 --- a/tests/hp/laplace.h +++ b/tests/hp/laplace.h @@ -427,7 +427,7 @@ Laplace::refine_grid(const unsigned int cycle) // 3.2. Mark cells for h-refinement mark_h_cells(); - // 3.3. Substitute h for p refinement + // 3.3. Substitute h- for p-refinement substitute_h_for_p(); // prepare refinement and store number of flagged cells @@ -457,7 +457,7 @@ Laplace::refine_grid(const unsigned int cycle) // 3.5. h-refinement and p-refinement triangulation.execute_coarsening_and_refinement(); - // FIXME: some hp strategies might need: + // FIXME: some hp-strategies might need: // post_execute_coarsening_and_refinement(); // 3.6. Setup diff --git a/tests/hp/matrices.cc b/tests/hp/matrices.cc index d627af1b8f..948dba7165 100644 --- a/tests/hp/matrices.cc +++ b/tests/hp/matrices.cc @@ -15,7 +15,7 @@ -// like deal.II/matrices, but for hp objects. here, each hp object has only a +// like deal.II/matrices, but for hp-objects. here, each hp-object has only a // single component, so we expect exactly the same output as for the old test. // matrices_hp tests for different finite elements diff --git a/tests/hp/n_boundary_dofs.cc b/tests/hp/n_boundary_dofs.cc index 78b3b81a40..ae11174800 100644 --- a/tests/hp/n_boundary_dofs.cc +++ b/tests/hp/n_boundary_dofs.cc @@ -16,7 +16,7 @@ // Check the consistency of the number cache of DoFHandler for a sequential -// object. Like deal.II/n_boundary_dofs but for an hp object +// object. Like deal.II/n_boundary_dofs but for an hp-object #include diff --git a/tests/hp/p_adaptivity_absolute_threshold.cc b/tests/hp/p_adaptivity_absolute_threshold.cc index e654b03d1e..667cf574ea 100644 --- a/tests/hp/p_adaptivity_absolute_threshold.cc +++ b/tests/hp/p_adaptivity_absolute_threshold.cc @@ -99,8 +99,8 @@ test() // We flag the first half of all cells to be refined and the last half of all - // cells to be coarsened for p adapativity. Ultimately, the first quarter of - // all cells will be flagged for p refinement, and the last quarter for p + // cells to be coarsened for p-adapativity. Ultimately, the first quarter of + // all cells will be flagged for p-refinement, and the last quarter for p- // coarsening. const unsigned int n_active = tria.n_active_cells(); diff --git a/tests/hp/p_adaptivity_fixed_number.cc b/tests/hp/p_adaptivity_fixed_number.cc index 6bc7fd0b47..f015a4b738 100644 --- a/tests/hp/p_adaptivity_fixed_number.cc +++ b/tests/hp/p_adaptivity_fixed_number.cc @@ -99,8 +99,8 @@ test() // We flag the first half of all cells to be refined and the last half of all - // cells to be coarsened for p adapativity. Ultimately, the first quarter of - // all cells will be flagged for p refinement, and the last quarter for p + // cells to be coarsened for p-adapativity. Ultimately, the first quarter of + // all cells will be flagged for p-refinement, and the last quarter for p- // coarsening. const unsigned int n_active = tria.n_active_cells(); diff --git a/tests/hp/p_adaptivity_flags.cc b/tests/hp/p_adaptivity_flags.cc index 1744d0aa0d..f8e66eb71e 100644 --- a/tests/hp/p_adaptivity_flags.cc +++ b/tests/hp/p_adaptivity_flags.cc @@ -99,8 +99,8 @@ test() // We flag the first half of all cells to be refined and the last half of all - // cells to be coarsened for p adapativity. Ultimately, the first quarter of - // all cells will be flagged for p refinement, and the last quarter for p + // cells to be coarsened for p-adapativity. Ultimately, the first quarter of + // all cells will be flagged for p-refinement, and the last quarter for p- // coarsening. const unsigned int n_active = tria.n_active_cells(); diff --git a/tests/hp/p_adaptivity_reference.cc b/tests/hp/p_adaptivity_reference.cc index 7d9564fdcd..e9dcdc5e18 100644 --- a/tests/hp/p_adaptivity_reference.cc +++ b/tests/hp/p_adaptivity_reference.cc @@ -99,8 +99,8 @@ test() // We flag the first half of all cells to be refined and the last half of all - // cells to be coarsened for p adapativity. Ultimately, the first quarter of - // all cells will be flagged for p refinement, and the last quarter for p + // cells to be coarsened for p-adapativity. Ultimately, the first quarter of + // all cells will be flagged for p-refinement, and the last quarter for p- // coarsening. const unsigned int n_active = tria.n_active_cells(); diff --git a/tests/hp/p_adaptivity_regularity.cc b/tests/hp/p_adaptivity_regularity.cc index e882b25285..8bf7e1de3a 100644 --- a/tests/hp/p_adaptivity_regularity.cc +++ b/tests/hp/p_adaptivity_regularity.cc @@ -99,8 +99,8 @@ test() // We flag the first half of all cells to be refined and the last half of all - // cells to be coarsened for p adapativity. Ultimately, the first quarter of - // all cells will be flagged for p refinement, and the last quarter for p + // cells to be coarsened for p-adapativity. Ultimately, the first quarter of + // all cells will be flagged for p-refinement, and the last quarter for p- // coarsening. const unsigned int n_active = tria.n_active_cells(); diff --git a/tests/hp/p_adaptivity_relative_threshold.cc b/tests/hp/p_adaptivity_relative_threshold.cc index 2a265b35bf..53aab49f80 100644 --- a/tests/hp/p_adaptivity_relative_threshold.cc +++ b/tests/hp/p_adaptivity_relative_threshold.cc @@ -99,8 +99,8 @@ test() // We flag the first half of all cells to be refined and the last half of all - // cells to be coarsened for p adapativity. Ultimately, the first quarter of - // all cells will be flagged for p refinement, and the last quarter for p + // cells to be coarsened for p-adapativity. Ultimately, the first quarter of + // all cells will be flagged for p-refinement, and the last quarter for p- // coarsening. const unsigned int n_active = tria.n_active_cells(); diff --git a/tests/hp/set_dof_values_by_interpolation_01.cc b/tests/hp/set_dof_values_by_interpolation_01.cc index 18f7811c40..ef1fe4ba11 100644 --- a/tests/hp/set_dof_values_by_interpolation_01.cc +++ b/tests/hp/set_dof_values_by_interpolation_01.cc @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- -// cell->set_dof_values_by_interpolation can not work properly in the hp +// cell->set_dof_values_by_interpolation can not work properly in the hp- // context when called on non-active cells because these do not have a // finite element associated with them diff --git a/tests/hp/set_dof_values_by_interpolation_02.cc b/tests/hp/set_dof_values_by_interpolation_02.cc index ef147071a0..5e43b4ed55 100644 --- a/tests/hp/set_dof_values_by_interpolation_02.cc +++ b/tests/hp/set_dof_values_by_interpolation_02.cc @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- -// cell->set_dof_values_by_interpolation can not work properly in the hp +// cell->set_dof_values_by_interpolation can not work properly in the hp- // context when called on non-active cells because these do not have a // finite element associated with them // diff --git a/tests/hp/set_dof_values_by_interpolation_03.cc b/tests/hp/set_dof_values_by_interpolation_03.cc index 91ee0ec954..a56584595b 100644 --- a/tests/hp/set_dof_values_by_interpolation_03.cc +++ b/tests/hp/set_dof_values_by_interpolation_03.cc @@ -14,7 +14,7 @@ // --------------------------------------------------------------------- -// cell->set_dof_values_by_interpolation can not work properly in the hp +// cell->set_dof_values_by_interpolation can not work properly in the hp- // context when called on non-active cells because these do not have a // finite element associated with them // diff --git a/tests/hp/solution_transfer.cc b/tests/hp/solution_transfer.cc index 766910f102..9f9e931873 100644 --- a/tests/hp/solution_transfer.cc +++ b/tests/hp/solution_transfer.cc @@ -208,7 +208,7 @@ transfer(std::ostream &out) std::fabs(func.value(fe_val.quadrature_point(q), 0) - vals[q]); } } - deallog << "Error in interpolating hp FE_Q: " << error << std::endl; + deallog << "Error in interpolating hp-FE_Q: " << error << std::endl; } { double error = 0; @@ -231,7 +231,7 @@ transfer(std::ostream &out) std::fabs(func.value(fe_val.quadrature_point(q), 0) - vals[q]); } } - deallog << "Error in interpolating hp FE_DGQ: " << error << std::endl; + deallog << "Error in interpolating hp-FE_DGQ: " << error << std::endl; } } diff --git a/tests/hp/solution_transfer.output b/tests/hp/solution_transfer.output index 7af228e047..95080fd65a 100644 --- a/tests/hp/solution_transfer.output +++ b/tests/hp/solution_transfer.output @@ -1,10 +1,10 @@ DEAL:: 1D solution transfer -DEAL::Error in interpolating hp FE_Q: 0 -DEAL::Error in interpolating hp FE_DGQ: 0 +DEAL::Error in interpolating hp-FE_Q: 0 +DEAL::Error in interpolating hp-FE_DGQ: 0 DEAL:: 2D solution transfer -DEAL::Error in interpolating hp FE_Q: 0 -DEAL::Error in interpolating hp FE_DGQ: 0 +DEAL::Error in interpolating hp-FE_Q: 0 +DEAL::Error in interpolating hp-FE_DGQ: 0 DEAL:: 3D solution transfer -DEAL::Error in interpolating hp FE_Q: 0 -DEAL::Error in interpolating hp FE_DGQ: 0 +DEAL::Error in interpolating hp-FE_Q: 0 +DEAL::Error in interpolating hp-FE_DGQ: 0 diff --git a/tests/hp/solution_transfer_02.cc b/tests/hp/solution_transfer_02.cc index 8c3495b20f..7d7e622017 100644 --- a/tests/hp/solution_transfer_02.cc +++ b/tests/hp/solution_transfer_02.cc @@ -16,7 +16,7 @@ // SolutionTransfer wanted to compute interpolation matrices between -// all pairs of elements used on a mesh in the hp case. unfortunately, +// all pairs of elements used on a mesh in the hp-case. unfortunately, // not all pairs are actually supported, e.g. between FE_Nothing and // FE_Q, but that shouldn't matter as long as these combinations are // never exercised on actual cells diff --git a/tests/hp/solution_transfer_12.cc b/tests/hp/solution_transfer_12.cc index bbf643554b..8d8fc0b926 100644 --- a/tests/hp/solution_transfer_12.cc +++ b/tests/hp/solution_transfer_12.cc @@ -222,7 +222,7 @@ transfer(std::ostream &out) std::fabs(func.value(fe_val.quadrature_point(q), 0) - vals[q]); } } - deallog << "Error in interpolating hp FE_Q_Hierarchical: " << error + deallog << "Error in interpolating hp-FE_Q_Hierarchical: " << error << std::endl; } } diff --git a/tests/hp/solution_transfer_12.output b/tests/hp/solution_transfer_12.output index adc30e4418..b32d35acbf 100644 --- a/tests/hp/solution_transfer_12.output +++ b/tests/hp/solution_transfer_12.output @@ -1,7 +1,7 @@ DEAL:: 1D solution transfer -DEAL::Error in interpolating hp FE_Q_Hierarchical: 0 +DEAL::Error in interpolating hp-FE_Q_Hierarchical: 0 DEAL:: 2D solution transfer -DEAL::Error in interpolating hp FE_Q_Hierarchical: 0 +DEAL::Error in interpolating hp-FE_Q_Hierarchical: 0 DEAL:: 3D solution transfer -DEAL::Error in interpolating hp FE_Q_Hierarchical: 0 +DEAL::Error in interpolating hp-FE_Q_Hierarchical: 0 diff --git a/tests/hp/vectors_boundary_rhs_01.cc b/tests/hp/vectors_boundary_rhs_01.cc index b3c3932d2a..fd17c0bebd 100644 --- a/tests/hp/vectors_boundary_rhs_01.cc +++ b/tests/hp/vectors_boundary_rhs_01.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_boundary_rhs, but for hp objects. here, each hp object +// like deal.II/vectors_boundary_rhs, but for hp-objects. here, each hp-object // has only a single component, so we expect exactly the same output as for the // old test. vectors_boundary_rhs_hp tests for different finite elements diff --git a/tests/hp/vectors_boundary_rhs_02.cc b/tests/hp/vectors_boundary_rhs_02.cc index 768ed0451e..68475e5b67 100644 --- a/tests/hp/vectors_boundary_rhs_02.cc +++ b/tests/hp/vectors_boundary_rhs_02.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_boundary_rhs_02_02, but for hp objects. here, each hp +// like deal.II/vectors_boundary_rhs_02_02, but for hp-objects. here, each hp- // object has only a single component, so we expect exactly the same output as // for the old test. vectors_boundary_rhs_02_hp tests for different finite // elements diff --git a/tests/hp/vectors_boundary_rhs_03.cc b/tests/hp/vectors_boundary_rhs_03.cc index a4bf3358ea..4a54b04c5a 100644 --- a/tests/hp/vectors_boundary_rhs_03.cc +++ b/tests/hp/vectors_boundary_rhs_03.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_boundary_rhs_03, but for hp objects. here, each hp +// like deal.II/vectors_boundary_rhs_03, but for hp-objects. here, each hp- // object has only a single component, so we expect exactly the same output as // for the old test. vectors_boundary_rhs_03_hp tests for different finite // elements diff --git a/tests/hp/vectors_boundary_rhs_hp_01.cc b/tests/hp/vectors_boundary_rhs_hp_01.cc index 369c82eb09..10a743423d 100644 --- a/tests/hp/vectors_boundary_rhs_hp_01.cc +++ b/tests/hp/vectors_boundary_rhs_hp_01.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_boundary_rhs, but for hp objects. here, each hp object +// like deal.II/vectors_boundary_rhs, but for hp-objects. here, each hp-object // has only a single component, so we expect exactly the same output as for the // old test. vectors_boundary_rhs_hp_hp tests for different finite elements diff --git a/tests/hp/vectors_boundary_rhs_hp_03.cc b/tests/hp/vectors_boundary_rhs_hp_03.cc index 0f10120e06..29a5a584b7 100644 --- a/tests/hp/vectors_boundary_rhs_hp_03.cc +++ b/tests/hp/vectors_boundary_rhs_hp_03.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_boundary_rhs_03, but for hp objects. here, each hp +// like deal.II/vectors_boundary_rhs_03, but for hp-objects. here, each hp- // object has only a single component, so we expect exactly the same output as // for the old test. vectors_boundary_rhs_hp_03_hp tests for different finite // elements diff --git a/tests/hp/vectors_point_source_01.cc b/tests/hp/vectors_point_source_01.cc index 7cc3a8ed0a..eadd54d729 100644 --- a/tests/hp/vectors_point_source_01.cc +++ b/tests/hp/vectors_point_source_01.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_point_source, but for hp objects. here, each hp object +// like deal.II/vectors_point_source, but for hp-objects. here, each hp-object // has only a single component, so we expect exactly the same output as for the // old test. vectors_point_source_hp tests for different finite elements diff --git a/tests/hp/vectors_point_source_hp_01.cc b/tests/hp/vectors_point_source_hp_01.cc index 32da843272..da496b81fa 100644 --- a/tests/hp/vectors_point_source_hp_01.cc +++ b/tests/hp/vectors_point_source_hp_01.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_point_source_hp, but for hp objects. here, each hp +// like deal.II/vectors_point_source_hp, but for hp-objects. here, each hp- // object has only a single component, so we expect exactly the same output as // for the old test. vectors_point_source_hp_hp tests for different finite // elements diff --git a/tests/hp/vectors_rhs_01.cc b/tests/hp/vectors_rhs_01.cc index 85adeb730c..4d46c55784 100644 --- a/tests/hp/vectors_rhs_01.cc +++ b/tests/hp/vectors_rhs_01.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_rhs, but for hp objects. here, each hp object has only a +// like deal.II/vectors_rhs, but for hp-objects. here, each hp-object has only a // single component, so we expect exactly the same output as for the old test. // vectors_rhs_hp tests for different finite elements diff --git a/tests/hp/vectors_rhs_02.cc b/tests/hp/vectors_rhs_02.cc index 4c1f4c1718..100f27064c 100644 --- a/tests/hp/vectors_rhs_02.cc +++ b/tests/hp/vectors_rhs_02.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_rhs_02_02, but for hp objects. here, each hp object has +// like deal.II/vectors_rhs_02_02, but for hp-objects. here, each hp-object has // only a single component, so we expect exactly the same output as for the old // test. vectors_rhs_02_hp tests for different finite elements diff --git a/tests/hp/vectors_rhs_03.cc b/tests/hp/vectors_rhs_03.cc index e0e0e5d8cc..e9ee27570f 100644 --- a/tests/hp/vectors_rhs_03.cc +++ b/tests/hp/vectors_rhs_03.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_rhs_03, but for hp objects. here, each hp object has +// like deal.II/vectors_rhs_03, but for hp-objects. here, each hp-object has // only a single component, so we expect exactly the same output as for the old // test. vectors_rhs_03_hp tests for different finite elements diff --git a/tests/hp/vectors_rhs_hp_01.cc b/tests/hp/vectors_rhs_hp_01.cc index 3e528a1db3..f8e5b6c6e2 100644 --- a/tests/hp/vectors_rhs_hp_01.cc +++ b/tests/hp/vectors_rhs_hp_01.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_rhs_hp, but for hp objects. here, each hp object has +// like deal.II/vectors_rhs_hp, but for hp-objects. here, each hp-object has // only a single component, so we expect exactly the same output as for the old // test. vectors_rhs_hp_hp tests for different finite elements diff --git a/tests/hp/vectors_rhs_hp_03.cc b/tests/hp/vectors_rhs_hp_03.cc index fad3704347..f461976bf2 100644 --- a/tests/hp/vectors_rhs_hp_03.cc +++ b/tests/hp/vectors_rhs_hp_03.cc @@ -15,7 +15,7 @@ -// like deal.II/vectors_rhs_hp_03, but for hp objects. here, each hp object has +// like deal.II/vectors_rhs_hp_03, but for hp-objects. here, each hp-object has // only a single component, so we expect exactly the same output as for the old // test. vectors_rhs_hp_03_hp tests for different finite elements diff --git a/tests/lac/inhomogeneous_constraints.cc b/tests/lac/inhomogeneous_constraints.cc index 3aca0df3a6..088dcc6c48 100644 --- a/tests/lac/inhomogeneous_constraints.cc +++ b/tests/lac/inhomogeneous_constraints.cc @@ -17,7 +17,7 @@ // this function tests the correctness of the implementation of // inhomogeneous constraints. The program is a modification of the step-27 -// tutorial program with hp elements and the constraints arising in that +// tutorial program with hp-elements and the constraints arising in that // situation. the idea of the test is to set up a matrix with standard tools // (i.e., constraints and the boundary value list), and compare that with // the new function. diff --git a/tests/matrix_free/matrix_vector_hp.cc b/tests/matrix_free/matrix_vector_hp.cc index 00acbf8678..dbf4028d09 100644 --- a/tests/matrix_free/matrix_vector_hp.cc +++ b/tests/matrix_free/matrix_vector_hp.cc @@ -17,7 +17,7 @@ // this function tests the correctness of the implementation of matrix free // matrix-vector products by comparing with the result of deal.II sparse -// matrix for hp DoFHandler on a hyperball mesh with hanging nodes and finite +// matrix for hp-DoFHandler on a hyperball mesh with hanging nodes and finite // elements orders distributed randomly. #include diff --git a/tests/matrix_free/matrix_vector_hp_no_template.cc b/tests/matrix_free/matrix_vector_hp_no_template.cc index 4fad45acc6..660349b3d1 100644 --- a/tests/matrix_free/matrix_vector_hp_no_template.cc +++ b/tests/matrix_free/matrix_vector_hp_no_template.cc @@ -17,7 +17,7 @@ // this function tests the correctness of the implementation of matrix free // matrix-vector products by comparing with the result of deal.II sparse -// matrix for hp DoFHandler on a hyperball mesh with hanging nodes and finite +// matrix for hp-DoFHandler on a hyperball mesh with hanging nodes and finite // elements orders distributed randomly. #include diff --git a/tests/matrix_free/thread_correctness_hp.cc b/tests/matrix_free/thread_correctness_hp.cc index a03d86c2c0..852563232b 100644 --- a/tests/matrix_free/thread_correctness_hp.cc +++ b/tests/matrix_free/thread_correctness_hp.cc @@ -16,7 +16,7 @@ // this function tests the correctness of the implementation of parallel -// matrix free matrix-vector products for hp elements by comparing to the +// matrix free matrix-vector products for hp-elements by comparing to the // serial version #include diff --git a/tests/mpi/hp_step-4.cc b/tests/mpi/hp_step-4.cc index 4422ee967d..dd5c51cb17 100644 --- a/tests/mpi/hp_step-4.cc +++ b/tests/mpi/hp_step-4.cc @@ -197,7 +197,7 @@ namespace Step4 DoFTools::make_zero_boundary_constraints(dof_handler, constraints); #ifdef DEBUG - // We did not think about hp constraints on ghost cells yet. + // We did not think about hp-constraints on ghost cells yet. // Thus, we are content with verifying their consistency for now. IndexSet locally_active_dofs; DoFTools::extract_locally_active_dofs(dof_handler, locally_active_dofs); diff --git a/tests/mpi/hp_unify_dof_indices_01.cc b/tests/mpi/hp_unify_dof_indices_01.cc index 5bf5c77211..735624ac40 100644 --- a/tests/mpi/hp_unify_dof_indices_01.cc +++ b/tests/mpi/hp_unify_dof_indices_01.cc @@ -15,9 +15,9 @@ -// have a 2x1 coarse mesh (or 2x1x1) and verify DoF indices in the hp +// have a 2x1 coarse mesh (or 2x1x1) and verify DoF indices in the hp- // case with an FECollection that contains multiple copies of the same -// FE_Q(2) element. the hp code will unify DoF indices on boundaries +// FE_Q(2) element. the hp-code will unify DoF indices on boundaries // between all subdomains. diff --git a/tests/mpi/hp_unify_dof_indices_02.cc b/tests/mpi/hp_unify_dof_indices_02.cc index 93488af1e3..7c94888f82 100644 --- a/tests/mpi/hp_unify_dof_indices_02.cc +++ b/tests/mpi/hp_unify_dof_indices_02.cc @@ -15,9 +15,9 @@ -// have a 2x2 coarse mesh (or 2x2x1) and verify DoF indices in the hp +// have a 2x2 coarse mesh (or 2x2x1) and verify DoF indices in the hp- // case with an FECollection that contains multiple copies of the same -// FE_Q(2) element. the hp code will unify DoF indices on boundaries +// FE_Q(2) element. the hp-code will unify DoF indices on boundaries // between all subdomains. // // in this testcase, three FE objects are distributed on four cells, diff --git a/tests/mpi/hp_unify_dof_indices_03.cc b/tests/mpi/hp_unify_dof_indices_03.cc index fbf3436775..94b756561d 100644 --- a/tests/mpi/hp_unify_dof_indices_03.cc +++ b/tests/mpi/hp_unify_dof_indices_03.cc @@ -15,9 +15,9 @@ -// have a 2x2 coarse mesh (or 2x2x1) and verify DoF indices in the hp +// have a 2x2 coarse mesh (or 2x2x1) and verify DoF indices in the hp- // case with an FECollection that contains a FE_Q(4) and a FE_Q(2) element. -// the hp code will unify DoF indices on boundaries between all subdomains. +// the hp-code will unify DoF indices on boundaries between all subdomains. // // in this testcase, each cell has a face neighbor with a different // active_fe_index, which is either locally owned or a ghost cell. diff --git a/tests/mpi/hp_unify_dof_indices_04.cc b/tests/mpi/hp_unify_dof_indices_04.cc index 92c8ac3f34..8dc5a0756d 100644 --- a/tests/mpi/hp_unify_dof_indices_04.cc +++ b/tests/mpi/hp_unify_dof_indices_04.cc @@ -15,9 +15,9 @@ -// have a 2x2 coarse mesh (or 2x2x1) and verify DoF indices in the hp +// have a 2x2 coarse mesh (or 2x2x1) and verify DoF indices in the hp- // case with an FECollection that contains a FE_Q(4) and a FE_Q(2) element. -// the hp code will unify DoF indices on boundaries between all subdomains. +// the hp-code will unify DoF indices on boundaries between all subdomains. // // in this testcase, each cell has a face neighbor which is // - locally owned with the same active_fe_index diff --git a/tests/mpi/hp_unify_dof_indices_05.cc b/tests/mpi/hp_unify_dof_indices_05.cc index 78b09c0d74..9c60903471 100644 --- a/tests/mpi/hp_unify_dof_indices_05.cc +++ b/tests/mpi/hp_unify_dof_indices_05.cc @@ -15,9 +15,9 @@ -// have a 2x2 coarse mesh (or 2x2x1) and verify DoF indices in the hp +// have a 2x2 coarse mesh (or 2x2x1) and verify DoF indices in the hp- // case with an FECollection that contains a FE_Q(4) and a FE_Q(2) element. -// the hp code will unify DoF indices on boundaries between all subdomains. +// the hp-code will unify DoF indices on boundaries between all subdomains. // // in this testcase, each cell has a face neighbor which is // - locally owned with a different active_fe_index diff --git a/tests/mpi/hp_unify_dof_indices_06.cc b/tests/mpi/hp_unify_dof_indices_06.cc index 29684409c3..04b1658a73 100644 --- a/tests/mpi/hp_unify_dof_indices_06.cc +++ b/tests/mpi/hp_unify_dof_indices_06.cc @@ -15,9 +15,9 @@ -// have a 2x2 coarse mesh (or 2x2x1) and verify DoF indices in the hp +// have a 2x2 coarse mesh (or 2x2x1) and verify DoF indices in the hp- // case with an FECollection that contains multiple copies of the same -// FE_Q(2) element. the hp code will unify DoF indices on boundaries +// FE_Q(2) element. the hp-code will unify DoF indices on boundaries // between all subdomains. // // in this testcase, the dominating FE object is located on a cell diff --git a/tests/mpi/hp_unify_dof_indices_07.cc b/tests/mpi/hp_unify_dof_indices_07.cc index fecbb810b6..03d6915792 100644 --- a/tests/mpi/hp_unify_dof_indices_07.cc +++ b/tests/mpi/hp_unify_dof_indices_07.cc @@ -15,11 +15,11 @@ -// have a 2x1 coarse mesh (or 2x1x1) and verify DoF indices in the hp +// have a 2x1 coarse mesh (or 2x1x1) and verify DoF indices in the hp- // case with an FECollection that contains multiple copies of the same -// FE_Q(2) element. in the sequential case, the hp code will unify DoF +// FE_Q(2) element. in the sequential case, the hp-code will unify DoF // indices on boundaries between locally owned subdomains; in early -// versions of the parallel hp support, we don't do that, but the +// versions of the parallel hp-support, we don't do that, but the // final version now does // // this test gives a different perspective on this issue. in the _01 diff --git a/tests/mpi/hp_unify_dof_indices_08.cc b/tests/mpi/hp_unify_dof_indices_08.cc index bd22443032..3fd6d127b4 100644 --- a/tests/mpi/hp_unify_dof_indices_08.cc +++ b/tests/mpi/hp_unify_dof_indices_08.cc @@ -15,12 +15,12 @@ -// Read in a large grid from a file and distribute hp DoFs on it using +// Read in a large grid from a file and distribute hp-DoFs on it using // FE_Q elements of different orders on different cells. The // active_fe_index on each cell is determined in a mostly random way, // but so that it is the same regardless of the number of processors. // -// We used to treat hp DoF unification on vertices and faces +// We used to treat hp-DoF unification on vertices and faces // differently depending on whether we are in the interior of a // subdomain or at a processor boundary. But later versions of the // code did away with this distinction, and now the total number of diff --git a/tests/mpi/hp_unify_dof_indices_10.cc b/tests/mpi/hp_unify_dof_indices_10.cc index be0c4c43e7..3bc3c23bb3 100644 --- a/tests/mpi/hp_unify_dof_indices_10.cc +++ b/tests/mpi/hp_unify_dof_indices_10.cc @@ -15,9 +15,9 @@ -// have a 2x2 coarse mesh (or 2x2x1) and verify DoF indices in the hp +// have a 2x2 coarse mesh (or 2x2x1) and verify DoF indices in the hp- // case with an FECollection that contains multiple copies of the same -// FESystem object, consisting of two FE_Q(2) elements. the hp code will +// FESystem object, consisting of two FE_Q(2) elements. the hp-code will // unify DoF indices on boundaries between all subdomains. // // in this testcase, three FESystem objects are distributed on four diff --git a/tests/mpi/hp_unify_dof_indices_11.cc b/tests/mpi/hp_unify_dof_indices_11.cc index 3775fcb1f9..091a5e76c5 100644 --- a/tests/mpi/hp_unify_dof_indices_11.cc +++ b/tests/mpi/hp_unify_dof_indices_11.cc @@ -15,11 +15,11 @@ -// have a 2x1 coarse mesh (or 2x1x1) and verify DoF indices in the hp +// have a 2x1 coarse mesh (or 2x1x1) and verify DoF indices in the hp- // case with a FECollection that contains two finite elements that do // not dominate each other. Here, a (FE_Q(1) x FE_Q(2)) and a // (FE_Q(2) x FE_Q(1)) element on two separate subdomains face each -// other. the hp code will unify DoF indices on boundaries between all +// other. the hp-code will unify DoF indices on boundaries between all // subdomains. diff --git a/tests/mpi/p_adaptivity_fixed_number.cc b/tests/mpi/p_adaptivity_fixed_number.cc index 28e746eff6..fe8a8eff9e 100644 --- a/tests/mpi/p_adaptivity_fixed_number.cc +++ b/tests/mpi/p_adaptivity_fixed_number.cc @@ -104,8 +104,8 @@ test() // We flag the first half of all cells to be refined and the last half of all - // cells to be coarsened for p adapativity. Ultimately, the first quarter of - // all cells will be flagged for p refinement, and the last quarter for p + // cells to be coarsened for p-adapativity. Ultimately, the first quarter of + // all cells will be flagged for p-refinement, and the last quarter for p- // coarsening. Vector indicators(tria.n_active_cells()); diff --git a/tests/mpi/trilinos_step-27.cc b/tests/mpi/trilinos_step-27.cc index 20f2a35ef4..1aaa77c55a 100644 --- a/tests/mpi/trilinos_step-27.cc +++ b/tests/mpi/trilinos_step-27.cc @@ -226,7 +226,7 @@ namespace Step27 Functions::ZeroFunction(), constraints); #ifdef DEBUG - // We did not think about hp constraints on ghost cells yet. + // We did not think about hp-constraints on ghost cells yet. // Thus, we are content with verifying their consistency for now. IndexSet locally_active_dofs; DoFTools::extract_locally_active_dofs(dof_handler, locally_active_dofs); diff --git a/tests/vector_tools/boundaries_complex_hp.cc b/tests/vector_tools/boundaries_complex_hp.cc index cd1aeb27c9..061e2b7b07 100644 --- a/tests/vector_tools/boundaries_complex_hp.cc +++ b/tests/vector_tools/boundaries_complex_hp.cc @@ -16,7 +16,7 @@ // check interpolation of boundary values for complex-valued -// objects and the hp case +// objects and the hp-case #include -- 2.39.5