]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Remove underscores for active and future FE indices in the documentation. 11216/head
authorMarc Fehling <mafehling.git@gmail.com>
Thu, 19 Nov 2020 21:26:29 +0000 (14:26 -0700)
committerMarc Fehling <mafehling.git@gmail.com>
Fri, 18 Dec 2020 20:14:49 +0000 (13:14 -0700)
Write standalone FE in capitals.

105 files changed:
include/deal.II/distributed/solution_transfer.h
include/deal.II/dofs/dof_accessor.h
include/deal.II/dofs/dof_accessor.templates.h
include/deal.II/dofs/dof_handler.h
include/deal.II/fe/fe_tools.templates.h
include/deal.II/fe/fe_tools_interpolate.templates.h
include/deal.II/hp/fe_values.h
include/deal.II/hp/mapping_collection.h
include/deal.II/matrix_free/dof_info.h
include/deal.II/matrix_free/dof_info.templates.h
include/deal.II/matrix_free/face_setup_internal.h
include/deal.II/matrix_free/fe_evaluation.h
include/deal.II/matrix_free/mapping_info.templates.h
include/deal.II/matrix_free/matrix_free.h
include/deal.II/matrix_free/matrix_free.templates.h
include/deal.II/multigrid/mg_transfer_global_coarsening.templates.h
include/deal.II/numerics/solution_transfer.h
include/deal.II/numerics/vector_tools_boundary.templates.h
include/deal.II/numerics/vector_tools_interpolate.templates.h
include/deal.II/numerics/vector_tools_point_value.h
include/deal.II/numerics/vector_tools_rhs.h
source/distributed/error_predictor.cc
source/distributed/solution_transfer.cc
source/dofs/dof_accessor_get.cc
source/dofs/dof_accessor_set.cc
source/dofs/dof_handler.cc
source/dofs/dof_handler_policy.cc
source/dofs/dof_tools.cc
source/dofs/dof_tools_constraints.cc
source/fe/fe_bernstein.cc
source/fe/fe_enriched.cc
source/fe/fe_nothing.cc
source/fe/fe_system.cc
source/numerics/derivative_approximation.cc
source/numerics/point_value_history.cc
source/numerics/solution_transfer.cc
tests/bits/fe_tools_09.cc
tests/bits/fe_tools_10.cc
tests/bits/fe_tools_11.cc
tests/bits/fe_tools_cpfqpm_01.cc
tests/bits/fe_tools_cpfqpm_02.cc
tests/bits/fe_tools_cpfqpm_03.cc
tests/bits/fe_tools_cpfqpm_04.cc
tests/bits/fe_tools_cpfqpm_05.cc
tests/dofs/dof_tools_10.cc
tests/fe/fe_enriched_color_03.cc
tests/fe/fe_enriched_color_05.cc
tests/fe/fe_enriched_color_06.cc
tests/fe/fe_enriched_color_07.cc
tests/fe/fe_enriched_color_08.cc
tests/fe/fe_enriched_step-36.cc
tests/fe/fe_enriched_step-36b.cc
tests/fe/fe_nedelec_sz_non_rect_face.cc
tests/fe/injection_common.h
tests/fe/multiple_redistribute_dofs_01.cc
tests/fe/multiple_redistribute_dofs_02.cc
tests/fe/nedelec_crash_hp.cc
tests/fe/nedelec_non_rect_face.cc
tests/grid/grid_tools_extract_used_vertices_03.cc
tests/grid/grid_tools_find_closest_vertex_01.cc
tests/grid/grid_tools_find_closest_vertex_02.cc
tests/grid/grid_tools_halo_layer_04.cc
tests/grid/grid_tools_halo_layer_05.cc
tests/hp/crash_09.cc
tests/hp/crash_11.cc
tests/hp/crash_12.cc
tests/hp/crash_15.cc
tests/hp/crash_20.cc
tests/hp/create_rhs_01.cc
tests/hp/fe_collection_05.cc
tests/hp/fe_collection_06.cc
tests/hp/fe_hierarchy.cc
tests/hp/future_fe_indices.cc
tests/hp/get_interpolated_dof_values_01.debug.output
tests/hp/hp_constraints_common.h
tests/hp/hp_constraints_common_no_support.h
tests/hp/hp_q_hierarchical_constraints.cc
tests/hp/interpolate_nothing_02.cc
tests/hp/matrices_hp.cc
tests/hp/p_adaptivity_absolute_threshold.cc
tests/hp/p_adaptivity_fixed_number.cc
tests/hp/p_adaptivity_flags.cc
tests/hp/p_adaptivity_full.cc
tests/hp/p_adaptivity_reference.cc
tests/hp/p_adaptivity_regularity.cc
tests/hp/p_adaptivity_relative_threshold.cc
tests/hp/refinement_01.cc
tests/hp/set_dof_values_by_interpolation_01.debug.output
tests/hp/solution_transfer_09.cc
tests/lac/constraints.cc
tests/mpi/error_predictor_02.cc
tests/mpi/hp_active_fe_indices_transfer_01.cc
tests/mpi/hp_active_fe_indices_transfer_02.cc
tests/mpi/hp_active_fe_indices_transfer_03.cc
tests/mpi/hp_active_fe_indices_transfer_04.cc
tests/mpi/hp_constraints_consistent_01.cc
tests/mpi/hp_constraints_consistent_02.cc
tests/mpi/hp_constraints_consistent_03.cc
tests/mpi/hp_refinement_01.cc
tests/mpi/hp_refinement_02.cc
tests/mpi/hp_unify_dof_indices_09.cc
tests/mpi/p_adaptivity_fixed_number.cc
tests/mpi/solution_transfer_04.cc
tests/mpi/solution_transfer_05.cc
tests/numerics/project_parallel_qpmf_common.h

index f8b7082aac7440401940b5c54ad1a4418086ab7f..23d0c8084ca75128e4999ede62ec318f96dae992 100644 (file)
@@ -167,7 +167,7 @@ namespace parallel
      *
      * Transferring a solution across refinement works exactly like in the
      * non-hp-case. However, when considering serialization, we also have to
-     * store the active_fe_indices in an additional step. A code snippet
+     * 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
@@ -197,7 +197,7 @@ namespace parallel
      *
      * DoFHandler<dim,spacedim> hp_dof_handler(triangulation);
      * // We need to introduce our dof_handler to the fe_collection
-     * // before setting all active_fe_indices.
+     * // before setting all active FE indices.
      * hp_dof_handler.deserialize_active_fe_indices();
      * hp_dof_handler.distribute_dofs(fe_collection);
      *
index bea7a6188b15ebb716d24cde50d2bae970791178..081f1bbd647156999b16fe8e7b7bb48240548b0b 100644 (file)
@@ -539,8 +539,8 @@ public:
   n_active_fe_indices() const;
 
   /**
-   * 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
+   * 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
    * n_active_fe_indices() active finite elements, and this function can be
    * queried for their indices.
@@ -549,7 +549,7 @@ public:
   nth_active_fe_index(const unsigned int n) const;
 
   /**
-   * Returns all active fe indices on this object.
+   * Returns all active FE indices on this object.
    *
    * The size of the returned set equals the number of finite elements that
    * are active on this object.
@@ -1047,7 +1047,7 @@ public:
   n_active_fe_indices() const;
 
   /**
-   * Return the @p n-th active fe index on this object.
+   * Return the @p n-th active FE index on this object.
    *
    * Since vertices do not store the information necessary for this to be
    * calculated, this method just raises an exception and only exists to
index b564ce783c05186724608566c7e633b26e752485..d0d544490db38db24022a1aed6434c6b538676b4 100644 (file)
@@ -605,7 +605,7 @@ namespace internal
 
 
       /**
-       * Return the fe index of the n-th finite element active on a given
+       * Return the FE index of the n-th finite element active on a given
        * vertex.
        */
       template <int dim, int spacedim, int d>
@@ -618,7 +618,7 @@ namespace internal
       {
         Assert(d == dim || obj_level == 0, ExcNotImplemented());
 
-        // for cells only one active fe index available
+        // for cells only one active FE index available
         Assert(((d == dim) &&
                 (local_index != DoFHandler<dim, spacedim>::default_fe_index)) ==
                  false,
@@ -648,7 +648,7 @@ namespace internal
 
 
       /**
-       * Returns all active fe indices on a given vertex.
+       * Returns all active FE indices on a given vertex.
        *
        * The size of the returned set equals the number of finite elements that
        * are active on this vertex.
@@ -1641,7 +1641,7 @@ DoFAccessor<structdim, dim, spacedim, level_dof_access>::get_fe(
   const unsigned int fe_index) const
 {
   Assert(fe_index_is_active(fe_index) == true,
-         ExcMessage("This function can only be called for active fe indices"));
+         ExcMessage("This function can only be called for active FE indices"));
 
   return this->dof_handler->get_fe(fe_index);
 }
@@ -2201,7 +2201,7 @@ namespace internal
         const DoFCellAccessor<dim, spacedim, level_dof_access> &accessor)
       {
         if (accessor.dof_handler->hp_capability_enabled == false)
-          return 0; // ::DoFHandler only supports a single active fe with index
+          return 0; // ::DoFHandler only supports a single active FE with index
                     // zero
 
         Assert(
@@ -2229,7 +2229,7 @@ namespace internal
       {
         if (accessor.dof_handler->hp_capability_enabled == false)
           {
-            // ::DoFHandler only supports a single active fe with index zero
+            // ::DoFHandler only supports a single active FE with index zero
             AssertDimension(i, (DoFHandler<dim, spacedim>::default_fe_index));
             return;
           }
@@ -2260,7 +2260,7 @@ namespace internal
         if (accessor.dof_handler->hp_capability_enabled == false)
           return DoFHandler<dim, spacedim>::
             default_fe_index; // ::DoFHandler only supports
-                              // a single active fe with
+                              // a single active FE with
                               // index zero
 
         Assert(
@@ -2293,7 +2293,7 @@ namespace internal
       {
         if (accessor.dof_handler->hp_capability_enabled == false)
           {
-            // ::DoFHandler only supports a single active fe with index zero
+            // ::DoFHandler only supports a single active FE with index zero
             AssertDimension(i, (DoFHandler<dim, spacedim>::default_fe_index));
             return;
           }
@@ -2322,7 +2322,7 @@ namespace internal
         const DoFCellAccessor<dim, spacedim, level_dof_access> &accessor)
       {
         if (accessor.dof_handler->hp_capability_enabled == false)
-          return false; // ::DoFHandler only supports a single active fe with
+          return false; // ::DoFHandler only supports a single active FE with
                         // index zero
 
         Assert(
@@ -2350,7 +2350,7 @@ namespace internal
         const DoFCellAccessor<dim, spacedim, level_dof_access> &accessor)
       {
         if (accessor.dof_handler->hp_capability_enabled == false)
-          return; // ::DoFHandler only supports a single active fe with index
+          return; // ::DoFHandler only supports a single active FE with index
                   // zero
 
         Assert(
@@ -2777,13 +2777,13 @@ DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            this->is_active(),
          ExcMessage(
-           "You can not ask for the active_fe_index on a cell that has "
+           "You can not ask for the active FE index on a cell that has "
            "children because no degrees of freedom are assigned "
            "to this cell and, consequently, no finite element "
            "is associated with it."));
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            (this->is_locally_owned() || this->is_ghost()),
-         ExcMessage("You can only query active_fe_index information on cells "
+         ExcMessage("You can only query active FE index information on cells "
                     "that are either locally owned or (after distributing "
                     "degrees of freedom) are ghost cells."));
 
@@ -2800,13 +2800,13 @@ DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
 {
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            this->is_active(),
-         ExcMessage("You can not set the active_fe_index on a cell that has "
+         ExcMessage("You can not set the active FE index on a cell that has "
                     "children because no degrees of freedom will be assigned "
                     "to this cell."));
 
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            this->is_locally_owned(),
-         ExcMessage("You can only set active_fe_index information on cells "
+         ExcMessage("You can only set active FE index information on cells "
                     "that are locally owned. On ghost cells, this information "
                     "will automatically be propagated from the owning process "
                     "of that cell, and there is no information at all on "
@@ -2844,13 +2844,13 @@ DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            (this->has_children() == false),
          ExcMessage(
-           "You can not ask for the future_fe_index on a cell that has "
+           "You can not ask for the future FE index on a cell that has "
            "children because no degrees of freedom are assigned "
            "to this cell and, consequently, no finite element "
            "is associated with it."));
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            (this->is_locally_owned()),
-         ExcMessage("You can only query future_fe_index information on cells "
+         ExcMessage("You can only query future FE index information on cells "
                     "that are locally owned."));
 
   return dealii::internal::DoFCellAccessorImplementation::Implementation::
@@ -2866,13 +2866,13 @@ DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
 {
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            (this->has_children() == false),
-         ExcMessage("You can not set the future_fe_index on a cell that has "
+         ExcMessage("You can not set the future FE index on a cell that has "
                     "children because no degrees of freedom will be assigned "
                     "to this cell."));
 
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            this->is_locally_owned(),
-         ExcMessage("You can only set future_fe_index information on cells "
+         ExcMessage("You can only set future FE index information on cells "
                     "that are locally owned."));
 
   dealii::internal::DoFCellAccessorImplementation::Implementation::
@@ -2889,13 +2889,13 @@ DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            (this->has_children() == false),
          ExcMessage(
-           "You can not ask for the future_fe_index on a cell that has "
+           "You can not ask for the future FE index on a cell that has "
            "children because no degrees of freedom are assigned "
            "to this cell and, consequently, no finite element "
            "is associated with it."));
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            (this->is_locally_owned()),
-         ExcMessage("You can only query future_fe_index information on cells "
+         ExcMessage("You can only query future FE index information on cells "
                     "that are locally owned."));
 
   return dealii::internal::DoFCellAccessorImplementation::Implementation::
@@ -2912,13 +2912,13 @@ DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            (this->has_children() == false),
          ExcMessage(
-           "You can not ask for the future_fe_index on a cell that has "
+           "You can not ask for the future FE index on a cell that has "
            "children because no degrees of freedom are assigned "
            "to this cell and, consequently, no finite element "
            "is associated with it."));
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            (this->is_locally_owned()),
-         ExcMessage("You can only query future_fe_index information on cells "
+         ExcMessage("You can only query future FE index information on cells "
                     "that are locally owned."));
 
   dealii::internal::DoFCellAccessorImplementation::Implementation::
index a2291ac533609024375d2ace75704c6a37eb5760..47ecf1098feb282e29d4e1d3c917eae7f3415393 100644 (file)
@@ -534,8 +534,8 @@ public:
   using offset_type = unsigned int;
 
   /**
-   * Invalid active_fe_index which will be used as a default value to determine
-   *  whether a future_fe_index has been set or not.
+   * Invalid active FE index which will be used as a default value to determine
+   *  whether a future FE index has been set or not.
    */
   static const active_fe_index_type invalid_active_fe_index =
     static_cast<active_fe_index_type>(-1);
@@ -1270,7 +1270,7 @@ public:
   /**
    * Whenever serialization with a parallel::distributed::Triangulation as the
    * underlying triangulation is considered, we also need to consider storing
-   * the active_fe_indices on all active cells as well.
+   * the active FE indices on all active cells as well.
    *
    * This function registers that these indices are to be stored whenever the
    * parallel::distributed::Triangulation::save() function is called on the
@@ -1289,10 +1289,10 @@ public:
   /**
    * Whenever serialization with a parallel::distributed::Triangulation as the
    * underlying triangulation is considered, we also need to consider storing
-   * the active_fe_indices on all active cells as well.
+   * the active FE indices on all active cells as well.
    *
    * This function deserializes and distributes the previously stored
-   * active_fe_indices on all active cells.
+   * active FE indices on all active cells.
    *
    * @note Currently only implemented for triangulations of type
    *   parallel::distributed::Triangulation. An assertion will be triggered if
@@ -1376,7 +1376,7 @@ public:
   DeclException2(ExcInvalidFEIndex,
                  int,
                  int,
-                 << "The mesh contains a cell with an active_fe_index of "
+                 << "The mesh contains a cell with an active FE index of "
                  << arg1 << ", but the finite element collection only has "
                  << arg2 << " elements");
 
@@ -1477,7 +1477,7 @@ private:
 
   /**
    * Whenever the underlying triangulation changes by either
-   * h/p refinement/coarsening and serialization, the active_fe_index of cells
+   * h/p-refinement/coarsening and serialization, the active FE index of cells
    * needs to be transferred. This structure stores all temporary information
    * required during that process.
    */
@@ -1502,14 +1502,14 @@ private:
     std::map<const cell_iterator, const unsigned int> coarsened_cells_fe_index;
 
     /**
-     * Container to temporarily store the active_fe_index of every locally
+     * Container to temporarily store the active FE index of every locally
      * owned cell for transfer across parallel::distributed::Triangulation
      * objects.
      */
     std::vector<unsigned int> active_fe_indices;
 
     /**
-     * Helper object to transfer all active_fe_indices on
+     * Helper object to transfer all active FE indices on
      * parallel::distributed::Triangulation objects during
      * refinement/coarsening and serialization.
      */
@@ -1600,7 +1600,7 @@ private:
     object_dof_ptr;
 
   /**
-   * Active fe indices of each geometric object. Identification
+   * Active FE indices of each geometric object. Identification
    * of the appropriate position of a cell in the vectors is done via
    * hp_object_fe_ptr (CRS scheme).
    */
@@ -1608,19 +1608,19 @@ private:
     hp_object_fe_indices;
 
   /**
-   * Pointer to the first fe index of a geometric object.
+   * Pointer to the first FE index of a geometric object.
    */
   mutable std::array<std::vector<offset_type>, dim + 1> hp_object_fe_ptr;
 
   /**
-   * Active fe index of an active cell (identified by level and level index).
+   * Active FE index of an active cell (identified by level and level index).
    * This vector is only used in hp-mode.
    */
   mutable std::vector<std::vector<active_fe_index_type>>
     hp_cell_active_fe_indices;
 
   /**
-   * Future fe index of an active cell (identified by level and level index).
+   * Future FE index of an active cell (identified by level and level index).
    * This vector is only used in hp-mode.
    */
   mutable std::vector<std::vector<active_fe_index_type>>
@@ -1721,7 +1721,7 @@ private:
    * Update tables for active and future fe_indices.
    *
    * Whenever the underlying triangulation changes (either by adaptation or
-   * deserialization), active and future fe index tables will be adjusted to the
+   * deserialization), active and future FE index tables will be adjusted to the
    * current structure of the triangulation. Missing values of active and future
    * indices will be initialized with their defaults (see
    * create_active_fe_table()).
@@ -1737,7 +1737,7 @@ private:
    * signal just before the associated Triangulation or
    * parallel::shared::Triangulation is modified.
    *
-   * The function that stores the active_fe_indices of all cells that will
+   * The function that stores the active FE indices of all cells that will
    * be refined or coarsened before the refinement happens, so that
    * they can be set again after refinement.
    */
@@ -1749,7 +1749,7 @@ private:
    * signal just after the associated Triangulation or
    * parallel::shared::Triangulation is modified.
    *
-   * The function that restores the active_fe_indices of all cells that
+   * The function that restores the active FE indices of all cells that
    * were refined or coarsened.
    */
   void
@@ -1760,7 +1760,7 @@ private:
    * signal just before the associated parallel::distributed::Triangulation is
    * modified.
    *
-   * The function that stores all active_fe_indices on locally owned cells for
+   * The function that stores all active FE indices on locally owned cells for
    * distribution over all participating processors.
    */
   void
@@ -1771,7 +1771,7 @@ private:
    * signal just after the associated parallel::distributed::Triangulation is
    * modified.
    *
-   * The function that restores all active_fe_indices on locally owned cells
+   * The function that restores all active FE indices on locally owned cells
    * that have been communicated.
    */
   void
index 53cfaa1f0c7944c47090e4263976a888f3dc7b75..4a72f1d9cd6f91860040fdf784a2198e77d29ba2 100644 (file)
@@ -219,7 +219,7 @@ namespace FETools
       // given FEs
       unsigned int n_shape_functions = 0;
       for (unsigned int i = 0; i < fes.size(); ++i)
-        if (multiplicities[i] > 0) // check needed as fe might be nullptr
+        if (multiplicities[i] > 0) // check needed as FE might be nullptr
           n_shape_functions += fes[i]->n_dofs_per_cell() * multiplicities[i];
 
       // generate the array that will hold the output
@@ -386,27 +386,27 @@ namespace FETools
       // given FEs
       unsigned int n_shape_functions = 0;
       for (unsigned int i = 0; i < fes.size(); ++i)
-        if (multiplicities[i] > 0) // needed because fe might be nullptr
+        if (multiplicities[i] > 0) // needed because FE might be nullptr
           n_shape_functions += fes[i]->n_dofs_per_cell() * multiplicities[i];
 
       unsigned int n_components = 0;
       if (do_tensor_product)
         {
           for (unsigned int i = 0; i < fes.size(); ++i)
-            if (multiplicities[i] > 0) // needed because fe might be nullptr
+            if (multiplicities[i] > 0) // needed because FE might be nullptr
               n_components += fes[i]->n_components() * multiplicities[i];
         }
       else
         {
           for (unsigned int i = 0; i < fes.size(); ++i)
-            if (multiplicities[i] > 0) // needed because fe might be nullptr
+            if (multiplicities[i] > 0) // needed because FE might be nullptr
               {
                 n_components = fes[i]->n_components();
                 break;
               }
           // Now check that all FEs have the same number of components:
           for (unsigned int i = 0; i < fes.size(); ++i)
-            if (multiplicities[i] > 0) // needed because fe might be nullptr
+            if (multiplicities[i] > 0) // needed because FE might be nullptr
               Assert(n_components == fes[i]->n_components(),
                      ExcDimensionMismatch(n_components,
                                           fes[i]->n_components()));
index 47344852b9bd47a24f08d42dd5fc9ae9e063e20c..cac9b99d7496e83123c7b742710dfa6eb72ef7fd 100644 (file)
@@ -297,7 +297,7 @@ namespace FETools
       cell = dof1.begin_active(),
       endc = dof1.end();
 
-    // map from possible fe objects in
+    // map from possible FE objects in
     // dof1 to the back_interpolation
     // matrices
     std::map<const FiniteElement<dim> *, std::unique_ptr<FullMatrix<double>>>
index f4dfefe931446c1c779165e3c8b63d160d554767..690fd6ea0071c492d55e18dd622a277adb88dfb2 100644 (file)
@@ -248,7 +248,7 @@ namespace hp
    * hp::FECollection and hp::QCollection. Later on, when one sits on a
    * concrete cell, one would call the reinit() function for this particular
    * cell, just as one does for a regular ::FEValues object. The difference is
-   * that this time, the reinit() function looks up the active_fe_index of
+   * that this time, the reinit() function looks up the active FE index of
    * that cell, if necessary creates a ::FEValues object that matches the
    * finite element and quadrature formulas with that particular index in
    * their collections, and then re-initializes it for the current cell. The
@@ -260,7 +260,7 @@ namespace hp
    * The reinit() functions have additional arguments with default values. If
    * not specified, the function takes the index into the hp::FECollection,
    * hp::QCollection, and hp::MappingCollection objects from the
-   * active_fe_index of the cell, as explained above. However, one can also
+   * active FE index of the cell, as explained above. However, one can also
    * select different indices for a current cell. For example, by specifying a
    * different index into the hp::QCollection class, one does not need to sort
    * the quadrature objects in the quadrature collection so that they match
index d24a6229638a1b59ba09dd945b069453259881f3..e0f321582cbb4f395aa6f9fecfe7b48fb4e3ffd4 100644 (file)
@@ -100,7 +100,7 @@ namespace hp
 
     /**
      * Return the mapping object which was specified by the user for the
-     * active_fe_index which is provided as a parameter to this method.
+     * active FE index which is provided as a parameter to this method.
      *
      * @pre @p index must be between zero and the number of elements of the
      * collection.
index f1a2dc13ae1757fd66c343946510db9d721874d2..2d84bcad13b091ff9b704315a41d966a0fdab15e 100644 (file)
@@ -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<std::vector<unsigned int>> component_dof_indices_offset;
index b34582b003433f5ba55ee3eec0cc9e8f416a4fd8..432f2d505f6907c537c111f50ea7c88044e0c2cb 100644 (file)
@@ -520,7 +520,7 @@ namespace internal
     {
       (void)constraint_pool_row_index;
 
-      // first reorder the active fe index.
+      // first reorder the active FE index.
       const bool have_hp = dofs_per_cell.size() > 1;
       if (cell_active_fe_index.size() > 0)
         {
index a2f0c5462e52ec3ad0d95f79114dbf71291858b3..d480a4db252b70934ee88d09ed5deda538557dda 100644 (file)
@@ -1072,7 +1072,7 @@ namespace internal
       operator()(const FaceToCellTopology<length> &face1,
                  const FaceToCellTopology<length> &face2) const
       {
-        // check if active fe indices match
+        // check if active FE indices match
         if (active_fe_indices.size() > 0)
           {
             // ... for interior faces
index 3662a970c46cae28fa46f57f4d84210aa818c99a..1cd5f8ac8b161341f43a52d2f6c07a8eb405aab4 100644 (file)
@@ -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
@@ -360,7 +360,7 @@ 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;
 
index d6cddd792b615c12b5602b6d055a8540472443b9..98c48fe75606c8e4a7108766b40f051e1ab22d8e 100644 (file)
@@ -961,7 +961,7 @@ namespace internal
               dealii::FEValues<dim> &fe_val = *fe_values[my_q][fe_index];
               cell_data.resize(n_q_points);
 
-              // if the fe index has changed from the previous cell, set the
+              // if the FE index has changed from the previous cell, set the
               // old cell type to invalid (otherwise, we might detect
               // similarity due to some cells further ahead)
               if (my_q > 0)
@@ -1846,9 +1846,9 @@ namespace internal
                               1);
 #endif
 
-              // We assume that we have the faces sorted by the active fe
-              // indices so that the active fe index of the interior side of the
-              // face batch is the same as the fe index of the interior side of
+              // We assume that we have the faces sorted by the active FE
+              // indices so that the active FE index of the interior side of the
+              // face batch is the same as the FE index of the interior side of
               // its first entry.
               const unsigned int fe_index =
                 active_fe_index.size() > 0 ?
@@ -2026,9 +2026,9 @@ namespace internal
                           GeometryInfo<dim>::max_children_per_cell)
                         {
                           // We assume that we have the faces sorted by the
-                          // active fe indices so that the active fe index of
+                          // active FE indices so that the active FE index of
                           // the exterior side of the face batch is the same as
-                          // the fe index of the exterior side of its first
+                          // the FE index of the exterior side of its first
                           // entry.
                           const unsigned int fe_index =
                             active_fe_index.size() > 0 ?
index 1f82ed4fd7f7c5a7a496a2014781243181ddf40e..df9daf21f48be220bc5979a29745604fb22b34da 100644 (file)
@@ -1484,8 +1484,8 @@ public:
   /**
    * 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.
+   * FE indices. Use this function to compute what the subrange for a given pair
+   * of active FE indices is.
    */
   std::pair<unsigned int, unsigned int>
   create_inner_face_subrange_hp_by_index(
@@ -1497,8 +1497,8 @@ public:
   /**
    * 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.
+   * FE indices. Use this function to compute what the subrange for a given
+   * active FE indices is.
    */
   std::pair<unsigned int, unsigned int>
   create_boundary_face_subrange_hp_by_index(
index b2f3fab8937b10afaa5f5ada2caf5b31765eb38d..de7aac67612f428188f8fe0727ac22f3571406ec 100644 (file)
@@ -106,7 +106,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::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
index 17fd993f73d50630f68a96175cefc3a909e41a3a..2dda8777c641b481af1b6fd2abec4a31d5ed289c 100644 (file)
@@ -948,7 +948,7 @@ namespace internal
         dof_handler_coarse.get_fe(0).dofs_per_cell *
         GeometryInfo<dim>::max_children_per_cell;
 
-      // degree of fe on coarse and fine cell
+      // degree of FE on coarse and fine cell
       transfer.schemes[0].degree_coarse   = transfer.schemes[0].degree_fine =
         transfer.schemes[1].degree_coarse = dof_handler_coarse.get_fe(0).degree;
       transfer.schemes[1].degree_fine =
index 2da1e585e9921f218ad7a7b2f3df0cdcfb9b694f..4a124e1a1e33af60aac089b0528b808913cd0652 100644 (file)
@@ -297,7 +297,7 @@ DEAL_II_NAMESPACE_OPEN
  * finite elements that are part of the hp::FECollection associated with the
  * DoFHandler, should be considered on cells that are not active (i.e., that
  * have children). This is because degrees of freedom are only allocated for
- * active cells and, in fact, it is not allowed to set an active_fe_index on
+ * active cells and, in fact, it is not allowed to set an active FE index on
  * non- active cells using DoFAccessor::set_active_fe_index().
  *
  * It is, thus, not entirely natural what should happen if, for example, a few
@@ -320,7 +320,7 @@ DEAL_II_NAMESPACE_OPEN
  *   cell. After refinement, this Q3 function on the mother cell is then
  *   interpolated into the space the user has selected for this cell (which may
  *   be different from Q3, in this example, if the user has set the
- *   active_fe_index for a different space post-refinement and before calling
+ *   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
index 350ab9c5dc1f621de6188fe959b5b6fa3afef3de..18e5379abc268708551a0b6dfc4f812a95c241de 100644 (file)
@@ -367,7 +367,7 @@ namespace VectorTools
                             }
                         }
                       else
-                        // fe has only one component, so save some computations
+                        // FE has only one component, so save some computations
                         {
                           // get only the one component that this function has
                           dof_values_scalar.resize(fe.n_dofs_per_face(face_no));
index ace617504164f5e9ecb6b04e0b71496b64e615be..235d6ee7851da94989454ad5d88616d72f79d12d 100644 (file)
@@ -188,7 +188,7 @@ namespace VectorTools
               for (unsigned int m = 0; m < multiplicity; ++m)
                 {
                   // recursively call apply_transform to make sure to
-                  // correctly handle nested fe systems.
+                  // correctly handle nested FE systems.
                   current_offset = apply_transform(base_fe,
                                                    current_offset,
                                                    fe_values_jacobians,
@@ -276,7 +276,7 @@ namespace VectorTools
       std::vector<types::global_dof_index> dofs_on_cell(fe.max_dofs_per_cell());
 
       // Temporary storage for cell-wise interpolation operation. We store a
-      // variant for every fe we encounter to speed up resizing operations.
+      // variant for every FE we encounter to speed up resizing operations.
       // The first vector is used for local function evaluation. The vector
       // dof_values is used to store intermediate cell-wise interpolation
       // results (see the detailed explanation in the for loop further down
index 9d73967bbde77a85942f50e90fb6a3085a090bf8..3636aa34ea9217863d2f8b32a3f5e4ddd75bbfdb 100644 (file)
@@ -152,9 +152,9 @@ namespace VectorTools
    * Call the create_point_source_vector() function, see above, with
    * an implied default $Q_1$ mapping object.
    *
-   * Note that if your DoFHandler uses any active fe index other than zero, then
+   * Note that if your DoFHandler uses any active FE index other than zero, then
    * you need to call the function above that provides a mapping object for each
-   * active fe index.
+   * active FE index.
    */
   template <int dim, int spacedim>
   void
@@ -204,9 +204,9 @@ namespace VectorTools
    * Call the create_point_source_vector() function for vector-valued finite
    * elements, see above, with an implied default $Q_1$ mapping object.
    *
-   * Note that if your DoFHandler uses any active fe index other than zero, then
+   * Note that if your DoFHandler uses any active FE index other than zero, then
    * you need to call the function above that provides a mapping object for each
-   * active fe index.
+   * active FE index.
    */
   template <int dim, int spacedim>
   void
index d5894d315ddb1c15ea375b94df0c26adb9f20222..7516611332858ab605df9d78c30bc7a1ebe5eedd 100644 (file)
@@ -165,7 +165,7 @@ namespace VectorTools
   /**
    * Call the create_boundary_right_hand_side() function, see above, with a
    * single Q1 mapping as collection. This function therefore will only work
-   * if the only active fe index in use is zero.
+   * if the only active FE index in use is zero.
    *
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
index b854bd7307458fe9c96b505fd13672ed48a01875..1fb13c38f94561fe00a19a98f80419d7cfd266ed 100644 (file)
@@ -214,7 +214,7 @@ namespace parallel
                   (**estimated_error_it)[cell->active_cell_index()] *
                   (gamma_h * std::pow(.5, future_fe_degree));
 
-                // If the future fe index differs from the active one, also take
+                // If the future FE index differs from the active one, also take
                 // into account p-adaptation.
                 if (cell->future_fe_index_set())
                   *predicted_error_it *=
index b255be278014c91a3b9c466715dd0ae6e4a08fd5..779cbe1620ebe40b1852dbfb62adc2c0bcfd79af 100644 (file)
@@ -308,7 +308,7 @@ namespace parallel
                 dim,
                 DoFHandlerType::space_dimension>::CELL_COARSEN:
                 {
-                  // In case of coarsening, we need to find a suitable fe index
+                  // In case of coarsening, we need to find a suitable FE index
                   // for the parent cell. We choose the 'least dominant fe'
                   // on all children from the associated FECollection.
 #  ifdef DEBUG
@@ -383,10 +383,10 @@ namespace parallel
                 DoFHandlerType::space_dimension>::CELL_REFINE:
                 {
                   // After refinement, this particular cell is no longer active,
-                  // and its children have inherited its fe index. However, to
-                  // unpack the data on the old cell, we need to recover its fe
+                  // and its children have inherited its FE index. However, to
+                  // unpack the data on the old cell, we need to recover its FE
                   // index from one of the children. Just to be sure, we also
-                  // check if all children have the same fe index.
+                  // check if all children have the same FE index.
                   fe_index = cell->child(0)->active_fe_index();
                   for (unsigned int child_index = 1;
                        child_index < cell->n_children();
index b920452d47134c79440e3e2d2a07691230302d84..136aed8a7d56b92eeefffdefeb2600223d625e71 100644 (file)
@@ -111,7 +111,7 @@ DoFCellAccessor<dim, spacedim, lda>::get_interpolated_dof_values(
                "finite element index because they do not have naturally "
                "associated finite element spaces associated: degrees "
                "of freedom are only distributed on active cells for which "
-               "the active_fe_index has been set."));
+               "the active FE index has been set."));
 
       const FiniteElement<dim, spacedim> &fe =
         this->get_dof_handler().get_fe(fe_index);
index f4689c96a66e95c7b6af5fa134ec5ac7f44aa884..ca5dc3cf9633ed1988fbbbbe3daff49795516761 100644 (file)
@@ -101,7 +101,7 @@ DoFCellAccessor<dim, spacedim, lda>::set_dof_values_by_interpolation(
                "finite element index because they do not have naturally "
                "associated finite element spaces associated: degrees "
                "of freedom are only distributed on active cells for which "
-               "the active_fe_index has been set."));
+               "the active FE index has been set."));
 
       const FiniteElement<dim, spacedim> &fe =
         this->get_dof_handler().get_fe(fe_index);
index 47ee62b991b12764ba0028daba34c62013b3c848..f6becc13227b3ca69289743e7b76d3ef48fecd24 100644 (file)
@@ -1010,7 +1010,7 @@ namespace internal
       struct Implementation
       {
         /**
-         * No future_fe_indices should have been assigned when partitioning a
+         * No future FE indices should have been assigned when partitioning a
          * triangulation, since they are only available locally and will not be
          * communicated.
          */
@@ -1068,7 +1068,7 @@ namespace internal
                                      [cell->vertex_index(v)] = true;
 
                 // in debug mode, make sure that each vertex is associated
-                // with at least one fe (note that except for unused
+                // with at least one FE (note that except for unused
                 // vertices, all vertices are actually active). this is of
                 // course only true for vertices that are part of either
                 // ghost or locally owned cells
@@ -1237,7 +1237,7 @@ namespace internal
           // description in hp::DoFLevel) with the indices we will
           // need. Note that our task is more complicated than for the
           // cell case above since two adjacent cells may have different
-          // active_fe_indices, in which case we need to allocate
+          // active FE indices, in which case we need to allocate
           // *two* sets of face dofs for the same face. But they don't
           // *have* to be different, and so we need to prepare for this
           // as well.
@@ -1698,7 +1698,7 @@ namespace internal
 
         /**
          * Given a DoFHandler object in hp-mode, make sure that the
-         * active_fe_indices that a user has set for locally owned cells are
+         * active FE indices that a user has set for locally owned cells are
          * communicated to all other relevant cells as well.
          *
          * For parallel::shared::Triangulation objects,
@@ -1722,9 +1722,9 @@ namespace internal
             {
               // we have a shared triangulation. in this case, every processor
               // knows about all cells, but every processor only has knowledge
-              // about the active_fe_index on the cells it owns.
+              // about the active FE index on the cells it owns.
               //
-              // we can create a complete set of active_fe_indices by letting
+              // we can create a complete set of active FE indices by letting
               // every processor create a vector of indices for all cells,
               // filling only those on the cells it owns and setting the indices
               // on the other cells to zero. then we add all of these vectors
@@ -1741,7 +1741,7 @@ namespace internal
                                   tr->get_communicator(),
                                   active_fe_indices);
 
-              // now go back and fill the active_fe_index on all other
+              // now go back and fill the active FE index on all other
               // cells. we would like to call cell->set_active_fe_index(),
               // but that function does not allow setting these indices on
               // non-locally_owned cells. so we have to work around the
@@ -1809,7 +1809,7 @@ namespace internal
          * future refinement and coarsening. Further, prepare those indices to
          * be distributed on on the updated triangulation later.
          *
-         * On cells to be refined, the active_fe_index will be inherited to
+         * On cells to be refined, the active FE index will be inherited to
          * their children and thus will be stored as such.
          *
          * On cells to be coarsened, we choose the finite element on the parent
@@ -1821,7 +1821,7 @@ namespace internal
          * information.
          *
          * On cells intended for p-refinement or p-coarsening, those
-         * active_fe_indices will be determined by the corresponding flags that
+         * active FE indices will be determined by the corresponding flags that
          * have been set on the relevant cells.
          */
         template <int dim, int spacedim>
@@ -1836,7 +1836,7 @@ namespace internal
               {
                 if (cell->refine_flag_set())
                   {
-                    // Store the active_fe_index of each cell that will be
+                    // Store the active FE index of each cell that will be
                     // refined to and distribute it later on its children.
                     // Pick their future index if flagged for p-refinement.
                     fe_transfer->refined_cells_fe_index.insert(
@@ -1845,18 +1845,18 @@ namespace internal
                 else if (cell->coarsen_flag_set())
                   {
                     // From all cells that will be coarsened, determine their
-                    // parent and calculate its proper active_fe_index, so that
+                    // parent and calculate its proper active FE index, so that
                     // it can be set after refinement. But first, check if that
                     // particular cell has a parent at all.
                     Assert(cell->level() > 0, ExcInternalError());
                     const auto &parent = cell->parent();
 
-                    // Check if the active_fe_index for the current cell has
+                    // Check if the active FE index for the current cell has
                     // been determined already.
                     if (fe_transfer->coarsened_cells_fe_index.find(parent) ==
                         fe_transfer->coarsened_cells_fe_index.end())
                       {
-                        // Find a suitable active_fe_index for the parent cell
+                        // Find a suitable active FE index for the parent cell
                         // based on the 'least dominant finite element' of its
                         // children. Consider the childrens' hypothetical future
                         // index when they have been flagged for p-refinement.
@@ -1879,7 +1879,7 @@ namespace internal
                   {
                     // No h-refinement is scheduled for this cell.
                     // However, it may have p-refinement indicators, so we
-                    // choose a new active_fe_index based on its flags.
+                    // choose a new active FE index based on its flags.
                     if (cell->future_fe_index_set() == true)
                       fe_transfer->persisting_cells_fe_index.insert(
                         {cell, cell->future_fe_index()});
@@ -1900,7 +1900,7 @@ namespace internal
         {
           const auto &fe_transfer = dof_handler.active_fe_index_transfer;
 
-          // Set active_fe_indices on persisting cells.
+          // Set active FE indices on persisting cells.
           for (const auto &persist : fe_transfer->persisting_cells_fe_index)
             {
               const auto &cell = persist.first;
@@ -1912,7 +1912,7 @@ namespace internal
                 }
             }
 
-          // Distribute active_fe_indices from all refined cells on their
+          // Distribute active FE indices from all refined cells on their
           // respective children.
           for (const auto &refine : fe_transfer->refined_cells_fe_index)
             {
@@ -1926,7 +1926,7 @@ namespace internal
                 }
             }
 
-          // Set active_fe_indices on coarsened cells that have been determined
+          // Set active FE indices on coarsened cells that have been determined
           // before the actual coarsening happened.
           for (const auto &coarsen : fe_transfer->coarsened_cells_fe_index)
             {
@@ -1940,7 +1940,7 @@ namespace internal
 
         /**
          * Coarsening strategy for the CellDataTransfer object responsible for
-         * transferring the active_fe_index of each cell on
+         * transferring the active FE index of each cell on
          * parallel::distributed::Triangulation objects that have been refined.
          *
          * A finite element index needs to be determined for the (not yet
@@ -2440,7 +2440,7 @@ DoFHandler<dim, spacedim>::set_fe(const hp::FECollection<dim, spacedim> &ff)
           this->hp_cell_future_fe_indices.shrink_to_fit();
         }
 
-      // re-enabling hp-mode is not permitted since the active and future fe
+      // re-enabling hp-mode is not permitted since the active and future FE
       // tables are no longer available
       AssertThrow(
         hp_capability_enabled || !contains_multiple_fes,
@@ -2451,13 +2451,13 @@ DoFHandler<dim, spacedim>::set_fe(const hp::FECollection<dim, spacedim> &ff)
 
   if (hp_capability_enabled)
     {
-      // make sure every processor knows the active_fe_indices
+      // make sure every processor knows the active FE indices
       // on both its own cells and all ghost cells
       dealii::internal::hp::DoFHandlerImplementation::Implementation::
         communicate_active_fe_indices(*this);
 
-      // make sure that the fe collection is large enough to
-      // cover all fe indices presently in use on the mesh
+      // make sure that the FE collection is large enough to
+      // cover all FE indices presently in use on the mesh
       for (const auto &cell : this->active_cell_iterators())
         if (!cell->is_artificial())
           Assert(cell->active_fe_index() < this->fe_collection.size(),
@@ -2519,7 +2519,7 @@ DoFHandler<dim, spacedim>::distribute_dofs(
           this->hp_cell_future_fe_indices.shrink_to_fit();
         }
 
-      // re-enabling hp-mode is not permitted since the active and future fe
+      // re-enabling hp-mode is not permitted since the active and future FE
       // tables are no longer available
       AssertThrow(
         hp_capability_enabled || !contains_multiple_fes,
@@ -2534,14 +2534,14 @@ DoFHandler<dim, spacedim>::distribute_dofs(
   //
   if (hp_capability_enabled)
     {
-      // make sure every processor knows the active_fe_indices
+      // make sure every processor knows the active FE indices
       // on both its own cells and all ghost cells
       internal::hp::DoFHandlerImplementation::Implementation::
         communicate_active_fe_indices(*this);
 
 #ifdef DEBUG
-      // make sure that the fe collection is large enough to
-      // cover all fe indices presently in use on the mesh
+      // make sure that the FE collection is large enough to
+      // cover all FE indices presently in use on the mesh
       for (const auto &cell : this->active_cell_iterators())
         {
           if (!cell->is_artificial())
@@ -3043,7 +3043,7 @@ DoFHandler<dim, spacedim>::connect_to_triangulation_signals()
     [this]() { this->create_active_fe_table(); }));
 
   // attach corresponding callback functions dealing with the transfer of
-  // active_fe_indices depending on the type of triangulation
+  // active FE indices depending on the type of triangulation
   if (dynamic_cast<
         const dealii::parallel::DistributedTriangulationBase<dim, spacedim> *>(
         &this->get_triangulation()))
@@ -3123,7 +3123,7 @@ DoFHandler<dim, spacedim>::create_active_fe_table()
   this->hp_cell_future_fe_indices.resize(this->tria->n_levels());
 
   // then make sure that on each level we have the appropriate size
-  // of active_fe_indices; preset them to zero, i.e. the default FE
+  // of active FE indices; preset them to zero, i.e. the default FE
   for (unsigned int level = 0; level < this->hp_cell_future_fe_indices.size();
        ++level)
     {
@@ -3137,7 +3137,7 @@ DoFHandler<dim, spacedim>::create_active_fe_table()
         }
       else
         {
-          // Either the active_fe_indices have size zero because
+          // Either the active FE indices have size zero because
           // they were just created, or the correct size. Other
           // sizes indicate that something went wrong.
           Assert(this->hp_cell_active_fe_indices[level].size() ==
@@ -3148,7 +3148,7 @@ DoFHandler<dim, spacedim>::create_active_fe_table()
         }
 
       // it may be that the previous table was compressed; in that
-      // case, restore the correct active_fe_index. the fact that
+      // case, restore the correct active FE index. the fact that
       // this no longer matches the indices in the table is of no
       // importance because the current function is called at a
       // point where we have to recreate the dof_indices tables in
@@ -3183,13 +3183,13 @@ DoFHandler<dim, spacedim>::update_active_fe_table()
 
   for (unsigned int i = 0; i < this->hp_cell_future_fe_indices.size(); ++i)
     {
-      // Resize active_fe_indices vectors. Use zero indicator to extend.
+      // Resize active FE indices vectors. Use zero indicator to extend.
       this->hp_cell_active_fe_indices[i].resize(this->tria->n_raw_cells(i), 0);
 
-      // Resize future_fe_indices vectors. Make sure that all
-      // future_fe_indices have been cleared after refinement happened.
+      // Resize future FE indices vectors. Make sure that all
+      // future FE indices have been cleared after refinement happened.
       //
-      // We have used future_fe_indices to update all active_fe_indices
+      // We have used future FE indices to update all active FE indices
       // before refinement happened, thus we are safe to clear them now.
       this->hp_cell_future_fe_indices[i].assign(this->tria->n_raw_cells(i),
                                                 invalid_active_fe_index);
@@ -3233,12 +3233,12 @@ DoFHandler<dim, spacedim>::pre_distributed_transfer_action()
   active_fe_index_transfer = std::make_unique<ActiveFEIndexTransfer>();
 
   // If we work on a p::d::Triangulation, we have to transfer all
-  // active_fe_indices since ownership of cells may change. We will
+  // active FE indices since ownership of cells may change. We will
   // use our p::d::CellDataTransfer member to achieve this. Further,
   // we prepare the values in such a way that they will correspond to
-  // the active_fe_indices on the new mesh.
+  // the active FE indices on the new mesh.
 
-  // Gather all current future_fe_indices.
+  // Gather all current future FE indices.
   active_fe_index_transfer->active_fe_indices.resize(
     get_triangulation().n_active_cells(), numbers::invalid_unsigned_int);
 
@@ -3289,7 +3289,7 @@ DoFHandler<dim, spacedim>::post_transfer_action()
   dealii::internal::hp::DoFHandlerImplementation::Implementation::
     distribute_fe_indices_on_refined_cells(*this);
 
-  // We have to distribute the information about active_fe_indices
+  // We have to distribute the information about active FE indices
   // of all cells (including the artificial ones) on all processors,
   // if a parallel::shared::Triangulation has been used.
   dealii::internal::hp::DoFHandlerImplementation::Implementation::
@@ -3312,17 +3312,17 @@ DoFHandler<dim, spacedim>::post_distributed_transfer_action()
 
   Assert(this->active_fe_index_transfer != nullptr, ExcInternalError());
 
-  // Unpack active_fe_indices.
+  // Unpack active FE indices.
   this->active_fe_index_transfer->active_fe_indices.resize(
     this->get_triangulation().n_active_cells(), numbers::invalid_unsigned_int);
   this->active_fe_index_transfer->cell_data_transfer->unpack(
     this->active_fe_index_transfer->active_fe_indices);
 
-  // Update all locally owned active_fe_indices.
+  // Update all locally owned active FE indices.
   this->set_active_fe_indices(
     this->active_fe_index_transfer->active_fe_indices);
 
-  // Update active_fe_indices on ghost cells.
+  // Update active FE indices on ghost cells.
   dealii::internal::hp::DoFHandlerImplementation::Implementation::
     communicate_active_fe_indices(*this);
 
@@ -3378,9 +3378,9 @@ DoFHandler<dim, spacedim>::prepare_for_serialization_of_active_fe_indices()
     });
 
   // If we work on a p::d::Triangulation, we have to transfer all
-  // active fe indices since ownership of cells may change.
+  // active FE indices since ownership of cells may change.
 
-  // Gather all current active_fe_indices
+  // Gather all current active FE indices
   get_active_fe_indices(active_fe_index_transfer->active_fe_indices);
 
   // Attach to transfer object
@@ -3435,16 +3435,16 @@ DoFHandler<dim, spacedim>::deserialize_active_fe_indices()
                                                   fe_collection);
     });
 
-  // Unpack active_fe_indices.
+  // Unpack active FE indices.
   active_fe_index_transfer->active_fe_indices.resize(
     get_triangulation().n_active_cells(), numbers::invalid_unsigned_int);
   active_fe_index_transfer->cell_data_transfer->deserialize(
     active_fe_index_transfer->active_fe_indices);
 
-  // Update all locally owned active_fe_indices.
+  // Update all locally owned active FE indices.
   set_active_fe_indices(active_fe_index_transfer->active_fe_indices);
 
-  // Update active_fe_indices on ghost cells.
+  // Update active FE indices on ghost cells.
   dealii::internal::hp::DoFHandlerImplementation::Implementation::
     communicate_active_fe_indices(*this);
 
index 62f5531d9ff805af3d20e8f8bade7e9da7426dba..1a0b4d583e6cc60e9374349fb12c9681db3bb8fc 100644 (file)
@@ -223,7 +223,7 @@ namespace internal
 
           // Note: we may wish to have something here similar to what
           // we do for lines and quads, namely that we only identify
-          // dofs for any fe towards the most dominating one. however,
+          // dofs for any FE towards the most dominating one. however,
           // it is not clear whether this is actually necessary for
           // vertices at all, I can't think of a finite element that
           // would make that necessary...
@@ -297,7 +297,7 @@ namespace internal
                           // are not yet constrained to anything else,
                           // except for to each other. use the rule that
                           // we will always constrain the dof with the
-                          // higher fe index to the one with the lower,
+                          // higher FE index to the one with the lower,
                           // to avoid circular reasoning.
                           for (const auto &identity : identities)
                             {
@@ -1070,7 +1070,7 @@ namespace internal
 
           // Note: we may wish to have something here similar to what
           // we do for lines and quads, namely that we only identify
-          // dofs for any fe towards the most dominating one. however,
+          // dofs for any FE towards the most dominating one. however,
           // it is not clear whether this is actually necessary for
           // vertices at all, I can't think of a finite element that
           // would make that necessary...
@@ -1157,7 +1157,7 @@ namespace internal
                           // are not yet constrained to anything else,
                           // except for to each other. use the rule that
                           // we will always constrain the dof with the
-                          // higher fe index to the one with the lower,
+                          // higher FE index to the one with the lower,
                           // to avoid circular reasoning.
                           for (const auto &identity : identities)
                             {
@@ -1186,7 +1186,7 @@ namespace internal
                               // we need to work on.
                               //
                               // all degrees of freedom belonging to
-                              // dominating fe indices or to a processor
+                              // dominating FE indices or to a processor
                               // with a higher rank have been set at this
                               // point (either in Phase 2, or after the
                               // first ghost exchange in Phase 5). thus,
@@ -1459,7 +1459,7 @@ namespace internal
                                     // we need to work on.
                                     //
                                     // all degrees of freedom belonging to
-                                    // dominating fe indices or to a processor
+                                    // dominating FE indices or to a processor
                                     // with a higher rank have been set at this
                                     // point (either in Phase 2, or after the
                                     // first ghost exchange in Phase 5). thus,
@@ -1614,7 +1614,7 @@ namespace internal
                                 // we need to work on.
                                 //
                                 // all degrees of freedom belonging to
-                                // dominating fe indices or to a processor with
+                                // dominating FE indices or to a processor with
                                 // a higher rank have been set at this point
                                 // (either in Phase 2, or after the first ghost
                                 // exchange in Phase 5). thus, we only have to
@@ -1935,7 +1935,7 @@ namespace internal
                       // the previous indices were all valid. this really should
                       // be the case: we allocated space for these vertex dofs,
                       // i.e., at least one adjacent cell has a valid
-                      // active_fe_index, so there are DoFs that really live
+                      // active FE index, so there are DoFs that really live
                       // on this vertex. if check_validity is set, then we
                       // must make sure that they have been set to something
                       // useful
@@ -3919,7 +3919,7 @@ namespace internal
 
           // 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
+          // by a FE object adjacent to a ghost interface.  thus, we overwrite
           // the remaining invalid indices with the valid ones in this step.
           Implementation::merge_invalid_dof_indices_on_ghost_interfaces(
             *dof_handler);
@@ -4432,7 +4432,7 @@ namespace internal
 
               // 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.
+              // dominated by a FE object adjacent to a ghost interface.
               // thus, we overwrite the remaining invalid indices with the
               // valid ones in this step.
               Implementation::merge_invalid_dof_indices_on_ghost_interfaces(
index 773eec8ed4343ac1be5db7d1323c2bd7c6c93315..55d820ce8ca409fd18e9360228c2256e5c36e022 100644 (file)
@@ -701,7 +701,7 @@ namespace DoFTools
                     // non-primitive, but use usual convention (see docs)
                     {
                       // first get at the cell-global number of a face dof,
-                      // to ask the fe certain questions
+                      // to ask the FE certain questions
                       const unsigned int cell_index =
                         (dim == 1 ?
                            i :
@@ -2201,7 +2201,7 @@ namespace DoFTools
         for (unsigned int fe_index = 0; fe_index < fe_collection.size();
              ++fe_index)
           {
-            // check whether every fe in the collection has support points
+            // check whether every FE in the collection has support points
             Assert(fe_collection[fe_index].has_support_points(),
                    typename FiniteElement<dim>::ExcFEHasNoSupportPoints());
             q_coll_dummy.push_back(Quadrature<dim>(
index d1998c278f25da21d4cd7653fd598f9ab90339b4..d249d23b29c17c3fe55e182c2415678a7fdb7f7d 100644 (file)
@@ -646,7 +646,7 @@ namespace DoFTools
           for (const unsigned int face : cell->face_indices())
             if (cell->face(face)->has_children())
               {
-                // in any case, faces can have at most two active fe indices,
+                // in any case, faces can have at most two active FE indices,
                 // but here the face can have only one (namely the same as that
                 // from the cell we're sitting on), and each of the children can
                 // have only one as well. check this
@@ -664,7 +664,7 @@ namespace DoFTools
                            ExcInternalError());
 
                 // right now, all that is implemented is the case that both
-                // sides use the same fe
+                // sides use the same FE
                 for (unsigned int c = 0; c < cell->face(face)->n_children();
                      ++c)
                   if (!cell->neighbor_child_on_subface(face, c)
@@ -747,7 +747,7 @@ namespace DoFTools
             else
               {
                 // this face has no children, but it could still be that it is
-                // shared by two cells that use a different fe index. check a
+                // shared by two cells that use a different FE index. check a
                 // couple of things, but ignore the case that the neighbor is an
                 // artificial cell
                 if (!cell->at_boundary(face) &&
@@ -808,7 +808,7 @@ namespace DoFTools
                          RefinementCase<dim - 1>::isotropic_refinement,
                        ExcNotImplemented());
 
-                // in any case, faces can have at most two active fe indices,
+                // in any case, faces can have at most two active FE indices,
                 // but here the face can have only one (namely the same as that
                 // from the cell we're sitting on), and each of the children can
                 // have only one as well. check this
@@ -825,7 +825,7 @@ namespace DoFTools
 
                 // right now, all that is implemented is the case that both
                 // sides use the same fe, and not only that but also that all
-                // lines bounding this face and the children have the same fe
+                // lines bounding this face and the children have the same FE
                 for (unsigned int c = 0; c < cell->face(face)->n_children();
                      ++c)
                   if (!cell->neighbor_child_on_subface(face, c)
@@ -991,7 +991,7 @@ namespace DoFTools
             else
               {
                 // this face has no children, but it could still be that it is
-                // shared by two cells that use a different fe index. check a
+                // shared by two cells that use a different FE index. check a
                 // couple of things, but ignore the case that the neighbor is an
                 // artificial cell
                 if (!cell->at_boundary(face) &&
@@ -1086,7 +1086,7 @@ namespace DoFTools
                 // so now we've found a face of an active cell that has
                 // children. that means that there are hanging nodes here.
 
-                // in any case, faces can have at most two sets of active fe
+                // in any case, faces can have at most two sets of active FE
                 // indices, but here the face can have only one (namely the same
                 // as that from the cell we're sitting on), and each of the
                 // children can have only one as well. check this
@@ -1466,7 +1466,7 @@ namespace DoFTools
             else
               {
                 // this face has no children, but it could still be that it is
-                // shared by two cells that use a different fe index
+                // shared by two cells that use a different FE index
                 Assert(cell->face(face)->fe_index_is_active(
                          cell->active_fe_index()) == true,
                        ExcInternalError());
@@ -1474,12 +1474,12 @@ namespace DoFTools
                 // see if there is a neighbor that is an artificial cell. in
                 // that case, we're not interested in this interface. we test
                 // this case first since artificial cells may not have an
-                // active_fe_index set, etc
+                // active FE index set, etc
                 if (!cell->at_boundary(face) &&
                     cell->neighbor(face)->is_artificial())
                   continue;
 
-                // Only if there is a neighbor with a different active_fe_index
+                // Only if there is a neighbor with a different active FE index
                 // and the same h-level, some action has to be taken.
                 if ((dof_handler.has_hp_capabilities()) &&
                     !cell->face(face)->at_boundary() &&
index ee1c0f1a69d903cfba08a57cb5ea65ab1818856c..635e92e65f158c48c5d59c0caa1f8d386c587549 100644 (file)
@@ -260,7 +260,7 @@ std::vector<std::pair<unsigned int, unsigned int>>
 FE_Bernstein<dim, spacedim>::hp_line_dof_identities(
   const FiniteElement<dim, spacedim> &) const
 {
-  // Since this fe is not interpolatory but on the vertices, we can
+  // Since this FE is not interpolatory but on the vertices, we can
   // not identify dofs on lines and on quads even if there are dofs
   // on lines and on quads.
   //
@@ -276,7 +276,7 @@ FE_Bernstein<dim, spacedim>::hp_quad_dof_identities(
   const FiniteElement<dim, spacedim> &,
   const unsigned int) const
 {
-  // Since this fe is not interpolatory but on the vertices, we can
+  // Since this FE is not interpolatory but on the vertices, we can
   // not identify dofs on lines and on quads even if there are dofs
   // on lines and on quads.
   //
index f470b2e008c34e4bc30d1fed6280042b565f919f..4ecc154a166a3c4af4fcfc07b091f99550cbf906 100644 (file)
@@ -428,7 +428,7 @@ FE_Enriched<dim, spacedim>::initialize(
   Assert(fes.size() == multiplicities.size(),
          ExcDimensionMismatch(fes.size(), multiplicities.size()));
 
-  // Note that we need to skip every fe with multiplicity 0 in the following
+  // Note that we need to skip every FE with multiplicity 0 in the following
   // block of code
   this->base_to_block_indices.reinit(0, 0);
 
@@ -475,7 +475,7 @@ FE_Enriched<dim, spacedim>::initialize(
   // However, functions like interpolate_boundary_values() need all FEs inside
   // FECollection to be able to provide support points irrespectively whether
   // this FE sits on the boundary or not. Thus for moment just copy support
-  // points from fe system:
+  // points from FE system:
   {
     this->unit_support_points      = fe_system->unit_support_points;
     this->unit_face_support_points = fe_system->unit_face_support_points;
@@ -1296,8 +1296,8 @@ namespace ColorEnriched
        * on adjacent cells, an enriched FE [0 0 1] should exist and is
        * found as the least dominating finite element for the two cells by
        * DoFTools::make_hanging_node_constraints, using the above mentioned
-       * hp::FECollection functions. Denoting the fe set in adjacent cells as
-       * {1,3} and {2,3}, this implies that an fe set {3} needs to be added!
+       * hp::FECollection functions. Denoting the FE set in adjacent cells as
+       * {1,3} and {2,3}, this implies that an FE set {3} needs to be added!
        * Based on the predicate configuration, this may not be automatically
        * done without the following special treatment.
        */
@@ -1319,10 +1319,10 @@ namespace ColorEnriched
                   const auto nbr_fe_index =
                     cell->neighbor(face)->active_fe_index();
 
-                  // find corresponding fe set
+                  // find corresponding FE set
                   const auto nbr_fe_set = fe_sets.at(nbr_fe_index);
 
-                  // find intersection of the fe sets: fe_set and nbr_fe_set
+                  // find intersection of the FE sets: fe_set and nbr_fe_set
                   std::set<unsigned int> intersection_set;
                   std::set_intersection(
                     fe_set.begin(),
index 721f34f8a8adc90b88e1cb87cfe162c64039a54d..8f786e39c57669d02d44df98d33c94ee929a69c6 100644 (file)
@@ -220,7 +220,7 @@ FE_Nothing<dim, spacedim>::compare_for_domination(
     // if it does and the other is FE_Nothing, either can dominate
     return FiniteElementDomination::either_element_can_dominate;
   else
-    // otherwise we dominate whatever fe is provided
+    // otherwise we dominate whatever FE is provided
     return FiniteElementDomination::this_element_dominates;
 }
 
index de8169987ec8e4d5822d75d09d3ca2e3ec1b04c7..dc12e9a2eb5d03bd3d592259ba851d41ce75a167 100644 (file)
@@ -1625,7 +1625,7 @@ FESystem<dim, spacedim>::initialize(
   Assert(count_nonzeros(multiplicities) > 0,
          ExcMessage("You only passed FiniteElements with multiplicity 0."));
 
-  // Note that we need to skip every fe with multiplicity 0 in the following
+  // Note that we need to skip every FE with multiplicity 0 in the following
   // block of code
 
   this->base_to_block_indices.reinit(0, 0);
index 32822082ef9e7d52379a7ff97c3fcae637a1f7b1..f8b75fb40e1e8cf1bc5430428389dded05e76524 100644 (file)
@@ -787,7 +787,7 @@ namespace DerivativeApproximation
       // derivatives
       typename DerivativeDescription::Derivative projected_derivative;
 
-      // reinit fe values object...
+      // reinit FE values object...
       x_fe_midpoint_value.reinit(cell);
       const FEValues<dim> &fe_midpoint_value =
         x_fe_midpoint_value.get_present_fe_values();
@@ -825,7 +825,7 @@ namespace DerivativeApproximation
         {
           const auto neighbor = *neighbor_ptr;
 
-          // reinit fe values object...
+          // reinit FE values object...
           x_fe_midpoint_value.reinit(neighbor);
           const FEValues<dim> &neighbor_fe_midpoint_value =
             x_fe_midpoint_value.get_present_fe_values();
index 7fe5560a53d7164ce5aee68fc5c4f74564365410..2c190caf41f2f0ccff4c806d48e97be8675de9d9 100644 (file)
@@ -278,7 +278,7 @@ PointValueHistory<dim>::add_point(const Point<dim> &location)
   // the requested point for all finite
   // element components lie in the same cell.
   // this could possibly be violated if
-  // components use different fe orders,
+  // components use different FE orders,
   // requested points are on the edge or
   // vertex of a cell and we are unlucky with
   // floating point rounding. Worst case
index 1d6b1d147f1630e351769bd9aded8d810bb202fd..585c15f3dd7b2f94b06e629866661df50693aeba 100644 (file)
@@ -505,7 +505,7 @@ SolutionTransfer<dim, VectorType, DoFHandlerType>::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<typename VectorType::value_type> *data = nullptr;
                   const unsigned int active_fe_index = cell->active_fe_index();
index 14295bed5041242eff89e1e29994456c6eccea99..cf2401586cea651a49a23b522c2f8ad4f1712fbe 100644 (file)
@@ -29,8 +29,8 @@ template <int dim>
 void
 check_this(const FiniteElement<dim> &fe1, const FiniteElement<dim> &fe2)
 {
-  // check that the name of the fe
-  // and the name of the fe that we
+  // check that the name of the FE
+  // and the name of the FE that we
   // re-create from this name are
   // identitical. this is also a
   // pretty good indication that the
index 59758c7ddf4f804d7e60f0b5917f513b2350d789..1a00e2d3f65fb1a3bdf9c1579c9b780f2781338c 100644 (file)
@@ -51,8 +51,8 @@ template <int dim>
 void
 check_this(const FiniteElement<dim> &fe1, const FiniteElement<dim> &fe2)
 {
-  // check that the name of the fe
-  // and the name of the fe that we
+  // check that the name of the FE
+  // and the name of the FE that we
   // re-create from this name are
   // identitical. this is also a
   // pretty good indication that the
index 73a9059c0adefb75a8ed433dddfb762d6d1fcaf4..833ba6e6fdd411cf26ff097c4071fc08e1619ee4 100644 (file)
@@ -50,8 +50,8 @@ template <int dim>
 void
 check_this(const FiniteElement<dim> &fe1, const FiniteElement<dim> &fe2)
 {
-  // check that the name of the fe
-  // and the name of the fe that we
+  // check that the name of the FE
+  // and the name of the FE that we
   // re-create from this name are
   // identitical. this is also a
   // pretty good indication that the
index 1cb8ef0e67cf90e4eab60d790cf89ac4d78125b8..b9e3037082371efa5e10bbe389dd4f1c3ed3ce17 100644 (file)
@@ -45,7 +45,7 @@ check_this(const FiniteElement<dim> &fe, const FiniteElement<dim> & /*fe2*/)
   if (fe.n_components() != 1)
     return;
 
-  // ignore this check if this fe has already
+  // ignore this check if this FE has already
   // been treated
   static std::set<std::string> already_checked;
   if (already_checked.find(fe.get_name()) != already_checked.end())
index b7a56809b78bd67ece81ddc94fd6951592864eef..3b2f06c2fa5879cf378ea4bbb7d744c7140b25d7 100644 (file)
@@ -44,7 +44,7 @@ check_this(const FiniteElement<dim> &fe, const FiniteElement<dim> & /*fe2*/)
   if (fe.n_components() != 1)
     return;
 
-  // ignore this check if this fe has already
+  // ignore this check if this FE has already
   // been treated
   static std::set<std::string> already_checked;
   if (already_checked.find(fe.get_name()) != already_checked.end())
index 5115894aba21a950f1672ecc12266f8a36fae416..cea83da1edd5b1d60d7942e1421e6b764fe3651d 100644 (file)
@@ -45,7 +45,7 @@ check_this(const FiniteElement<dim> &fe, const FiniteElement<dim> & /*fe2*/)
   if (fe.n_components() != 1)
     return;
 
-  // ignore this check if this fe has already
+  // ignore this check if this FE has already
   // been treated
   static std::set<std::string> already_checked;
   if (already_checked.find(fe.get_name()) != already_checked.end())
index 6575dc41d2645ee418d2dc390f77f4290a981804..44040c6c50210736598dc104eb587fa3452e8f82 100644 (file)
@@ -44,7 +44,7 @@ check_this(const FiniteElement<dim> &fe, const FiniteElement<dim> & /*fe2*/)
   if (fe.n_components() != 1)
     return;
 
-  // ignore this check if this fe has already
+  // ignore this check if this FE has already
   // been treated
   static std::set<std::string> already_checked;
   if (already_checked.find(fe.get_name()) != already_checked.end())
index d33e8854be4b91207a4238ead6ab4f468e230169..a14fca62cdc0d32522d9de120dfb569ab20425e6 100644 (file)
@@ -90,7 +90,7 @@ check_this(const FiniteElement<dim, spacedim> &fe,
   if (fe.n_components() != 1)
     return;
 
-  // ignore this check if this fe has already
+  // ignore this check if this FE has already
   // been treated
   static std::set<std::string> already_checked;
   if (already_checked.find(fe.get_name()) != already_checked.end())
index 8bac2814e5b0f8600e401cb7d4532417bf01bbae..da251762af791dcc4a5ad092b1f86e1321eecf2b 100644 (file)
@@ -31,7 +31,7 @@ template <int dim>
 void
 check_this(const DoFHandler<dim> &dof_handler)
 {
-  // don't check if fe has no support
+  // don't check if FE has no support
   // points
   if (dof_handler.get_fe().get_unit_support_points().size() == 0)
     return;
index 270a806f301bd0437ea0d8c1ca7d814146ba9f0a..863f54dd629d6effb591486675cce208d5a42eb4 100644 (file)
@@ -16,7 +16,7 @@
 /*
  * Test function - ColorEnriched::internal::set_cellwise_color_set_and_fe_index
  * for a set of predicates.
- * Check for each cell, if appropriate fe index and color-index map is set.
+ * Check for each cell, if appropriate FE index and color-index map is set.
  * Color-index map associates different colors of different enrichment
  * functions with corresponding enrichment function index.
  */
@@ -123,13 +123,13 @@ main(int argc, char **argv)
     fe_sets);
 
   /*
-   * Run through active cells to check fe index, colors of
+   * Run through active cells to check FE index, colors of
    * enrichment functions associated with it.
    *
-   * A unique color set corresponds to an fe index.
+   * A unique color set corresponds to an FE index.
    *
-   * Eg: If an fe index 1 corresponds to color set {2,3},
-   * means that a cell with fe index 1 has enrichment functions
+   * Eg: If an FE index 1 corresponds to color set {2,3},
+   * means that a cell with FE index 1 has enrichment functions
    * which are colored 2 and 3. Here different enrichment function
    * have same color 2 but for a given cell only one of them would
    * be relevant. So all additional information we need is which
@@ -162,7 +162,7 @@ main(int argc, char **argv)
                   << color_predicate_pair.second << "):";
         }
 
-      // For a cell, print fe active index and corresponding fe set.
+      // For a cell, print FE active index and corresponding FE set.
       //{1,2} indicates 2 enrichment functions of color 1 and 2 are relevant.
       deallog << ":fe_active_index:" << cell->active_fe_index() << ":fe_set:";
       for (auto fe_set_element : fe_sets[cell->active_fe_index()])
index a737d0e687ed1febfd2e40eb8a7b121498d5c896..79a65fc38fffa4c083e51dd3dba81834ca4b379c 100644 (file)
@@ -233,7 +233,7 @@ main(int argc, char **argv)
     fe_nothing,
     fe_collection);
 
-  // print all the different fe sets needed by different cells
+  // print all the different FE sets needed by different cells
   deallog << "fe sets:" << std::endl;
   for (auto fe_set : fe_sets)
     {
index 61e15e1d8a07f27eb23efcefbbe1c7d5300d2ee9..e846f62daa1f61118a59d593af120b69f67b11f2 100644 (file)
@@ -118,7 +118,7 @@ main(int argc, char **argv)
       vec_enrichments.push_back(std::make_shared<ConstantFunction<dim>>(func));
     }
 
-  // Construct helper class to construct fe collection
+  // Construct helper class to construct FE collection
   FE_Q<dim>                         fe_base(2);
   FE_Q<dim>                         fe_enriched(1);
   static ColorEnriched::Helper<dim> fe_space(fe_base,
index 91bd1398073350f667a83fcd356708cd605e1d95..8356942c7d5f06ebafed294d7e69a74bc1aca474 100644 (file)
@@ -1350,7 +1350,7 @@ LaplaceProblem<dim>::build_fe_space()
         {
           pcout << "...start print fe indices" << std::endl;
 
-          // print fe index
+          // print FE index
           const std::string base_filename =
             "fe_indices" + dealii::Utilities::int_to_string(dim) + "_p" +
             dealii::Utilities::int_to_string(0);
@@ -1739,7 +1739,7 @@ LaplaceProblem<dim>::run()
   pcout << "...run problem" << std::endl;
   double norm_soln_old(0), norm_rel_change_old(1);
 
-  // Run making grids and building fe space only once.
+  // Run making grids and building FE space only once.
   initialize();
   build_fe_space();
 
index dc687540e020a179def556125e54e6269fd6341f..618d4cf554b9c3f644537a5556f84d62bce05be0 100644 (file)
@@ -247,7 +247,7 @@ main(int argc, char **argv)
         std::make_shared<Functions::ConstantFunction<dim>>(func));
     }
 
-  // Construct helper class to construct fe collection
+  // Construct helper class to construct FE collection
   FE_Q<dim> fe_base(2);
   FE_Q<dim> fe_enriched(1);
 
index 64b41895bcc1b7674cd2d2d29eea47f64ba8d9cf..d8918c9d34b6955ddf8dca8c0bdb6424042248ef 100644 (file)
@@ -246,7 +246,7 @@ namespace Step36
     fe_collection.push_back(
       FE_Enriched<dim>(FE_Q<dim>(2), FE_Q<dim>(1), &enrichment));
 
-    // assign fe index in the constructor so that FE/FE+POU is determined
+    // assign FE index in the constructor so that FE/FE+POU is determined
     // on the coarsest mesh to avoid issues like
     // +---------+----+----+
     // |         | fe |    |
index a306ec268ce640796687887c700ec4ea81cbf29b..cc386abea1e8ddf9ea9bf228d476a5b72272ce63 100644 (file)
@@ -256,7 +256,7 @@ namespace Step36
     // enriched elements (active_fe_index==1):
     fe_collection.push_back(FESystem<dim>(FE_Q<dim>(2), 1, FE_Q<dim>(1), 1));
 
-    // assign fe index in the constructor so that FE/FE+POU is determined
+    // assign FE index in the constructor so that FE/FE+POU is determined
     // on the coarsest mesh to avoid issues like
     // +---------+----+----+
     // |         | fe |    |
index 567713cd92e9d5265d9db0ac99d1dca11b0f37fd..e032441ff9eb781764b4faed43646b191836c725 100644 (file)
@@ -251,7 +251,7 @@ namespace Maxwell
         // Store computed values at quad points:
         fe_values[E_re].get_function_values(solution, sol);
 
-        // Calc values of curlE from fe solution:
+        // Calc values of curlE from FE solution:
         cell->get_dof_indices(local_dof_indices);
         // Loop over quad points to calculate solution:
         for (const auto q_point : fe_values.quadrature_point_indices())
index 60256e6dbd0105052a15f53d89371640714f8af5..65bbbf999d597dad46a7edcb18c2c995d6e62902 100644 (file)
@@ -80,7 +80,7 @@ do_check(const FiniteElement<dim> &coarse_fe, const FiniteElement<dim> &fine_fe)
         }
 
         // check 2: first to finer cells,
-        // then to finer fe
+        // then to finer FE
         {
           FullMatrix<double> tmp1(coarse_fe.dofs_per_cell,
                                   coarse_fe.dofs_per_cell);
index 3d59c9f4c731f68e78183239b3cb6133246ce8e9..77afe618abc5122985fe2e45468bb6b2160baebb 100644 (file)
@@ -50,7 +50,7 @@ test()
   DoFHandler<dim, spacedim> dh(tria);
   dh.distribute_dofs(fe);
 
-  // This stores a pointer to the fe in dh.
+  // This stores a pointer to the FE in dh.
   FEValues<dim, spacedim> fe_v(dh.get_fe(), QGauss<dim>(1), update_values);
 
   tria.refine_global(1);
index d466074277eb39372fbc2e4c0df77e5ebda4d40a..42f8c35e6f5b504c4783f6ea5744238e00da4570 100644 (file)
@@ -51,7 +51,7 @@ test()
   DoFHandler<dim, spacedim> dh(tria);
   dh.distribute_dofs(fe_collection);
 
-  // This stores a pointer to the fe in dh.
+  // This stores a pointer to the FE in dh.
   hp::FEValues<dim, spacedim> fe_v(dh.get_fe_collection(),
                                    hp::QCollection<dim>(QGauss<dim>(1)),
                                    update_values);
index ef8d46a992b5dd89eac8a506d830ab23ee1b03bd..598be2871d88839e455411eb1413db45b6d178e7 100644 (file)
@@ -83,7 +83,7 @@ test()
         deallog << "Testing " << fe[i].get_name() << " vs. " << fe[j].get_name()
                 << std::endl;
 
-        // set fe on coarse cell to 'i', on
+        // set FE on coarse cell to 'i', on
         // all fine cells to 'j'
         typename DoFHandler<dim>::active_cell_iterator cell =
           dof_handler.begin_active();
index 36c750c6f099170d4ad49e38b9caabb6aa8db22c..638d5da0229155d6bee3c06153a8735afd2975da 100644 (file)
@@ -252,7 +252,7 @@ namespace Maxwell
         // Store computed values at quad points:
         fe_values[E_re].get_function_values(solution, sol);
 
-        // Calc values of curlE from fe solution:
+        // Calc values of curlE from FE solution:
         cell->get_dof_indices(local_dof_indices);
         // Loop over quad points to calculate solution:
         for (const auto q_point : fe_values.quadrature_point_indices())
index eaf86935c27c193dde1d2b35977375b557f02756..31a762c614d08ebc8f59eeff2885146d7fc7e920 100644 (file)
@@ -40,7 +40,7 @@ test(const Point<spacedim> &p)
   GridGenerator::hyper_cube(tria);
   tria.refine_global(1);
 
-  // Vector fe
+  // Vector FE
   FESystem<dim, spacedim>   fe{FE_Q<dim, spacedim>(1), spacedim};
   DoFHandler<dim, spacedim> dh(tria);
   dh.distribute_dofs(fe);
index f69f2c4b52970ca2694b7b1c5f246c99888c0c5e..ba573cbcd338d585ab286dd4b10778094a1fd9d2 100644 (file)
@@ -40,7 +40,7 @@ test(const Point<spacedim> &p)
   GridGenerator::hyper_cube(tria);
   tria.refine_global(1);
 
-  // Vector fe
+  // Vector FE
   FESystem<dim, spacedim>   fe{FE_Q<dim, spacedim>(1), spacedim};
   DoFHandler<dim, spacedim> dh(tria);
   dh.distribute_dofs(fe);
index 9859dd756830144ca492ffd26f21af42a12ac5f8..3a5e4de6279d9f64cb467bb828c1c46e7cfc6703 100644 (file)
@@ -40,7 +40,7 @@ test(const Point<spacedim> &p, double displacement)
   GridGenerator::hyper_cube(tria);
   tria.refine_global();
 
-  // Vector fe
+  // Vector FE
   FESystem<dim, spacedim>   fe{FE_Q<dim, spacedim>(1), spacedim};
   DoFHandler<dim, spacedim> dh(tria);
   dh.distribute_dofs(fe);
index 8fd4c8a1492b4bb5e9c50a9d62deba0c75bd6e14..cb838440d51cb4bb6509a9861e09268cd41eb579 100644 (file)
@@ -114,7 +114,7 @@ test()
     write_vtk(dof_handler, filename.c_str());
   }
 
-  // Compute a halo layer around active fe index 2 and set it to active fe index
+  // Compute a halo layer around active FE index 2 and set it to active FE index
   // 3
   std::function<bool(const cell_iterator &)> predicate =
     IteratorFilters::ActiveFEIndexEqualTo(2, true);
index 0394e4349a546ec5d163e383a1da05ad29305d0f..08258d8a4b733feb1c71886be1ccc68992ff5d5a 100644 (file)
@@ -119,7 +119,7 @@ test()
     write_vtk(dof_handler, filename.c_str());
   }
 
-  // Compute a halo layer around active fe indices 2,3 and set it to active fe
+  // Compute a halo layer around active FE indices 2,3 and set it to active FE
   // index 4
   std::set<unsigned int> index_set;
   index_set.insert(2);
index e114c77ec5048c00617810e49696094d0776f0bc..59316d67c4dca0e69a04d01343c2fd7ce01544c4 100644 (file)
@@ -116,7 +116,7 @@ main()
   // out the numbers of the dofs that
   // belong to the shared edge
   // (that's the one that has three
-  // different fe indices associated
+  // different FE indices associated
   // with it). note that there is
   // only one such line so we can
   // quit the loop once we find it
index afc1f7f643b86bcef97ea18d17f093e85c34cacc..83ed24cc8801f50cc12bba52244c74b4857a8518 100644 (file)
@@ -98,7 +98,7 @@ main()
   // out the numbers of the dofs that
   // belong to the shared edge
   // (that's the one that has four
-  // different fe indices associated
+  // different FE indices associated
   // with it). note that there is
   // only one such line so we can
   // quit the loop once we find it
index 5d2ce3fd68696e74353fcccd1b55878ced2ed9dd..fe5365303b35a36b5305894e9ccece1f68dbd1b9 100644 (file)
@@ -20,7 +20,7 @@
 //
 // this code in particular tests some compensating code in
 // dof_tools.cc, where we have to make sure that we select a suitable
-// set of primary dofs. this is mostly trivial in 2d and for most fe
+// set of primary dofs. this is mostly trivial in 2d and for most FE
 // combinations in 3d as well. the exceptions are that it doesn't work
 // as easily in 3d for the combinations Q4/Q3, Q5/Q3, and
 // Q5/Q4. Higher order finite elements in 3d will probably only
@@ -91,7 +91,7 @@ test()
         deallog << "Testing " << fe[i].get_name() << " vs. " << fe[j].get_name()
                 << std::endl;
 
-        // set fe on coarse cell to 'i', on
+        // set FE on coarse cell to 'i', on
         // all fine cells to 'j'
         typename DoFHandler<dim>::active_cell_iterator cell =
           dof_handler.begin_active();
index 8c9443bd0cf3cc0edcd39900de67b846bbac3187..2d28efd72ac33887a1106c77e164345b9dac59d3 100644 (file)
@@ -102,9 +102,9 @@ test()
             }
 
 
-          // if there are multiple active fe
+          // if there are multiple active FE
           // indices, make sure that all their
-          // fe indices were unified
+          // FE indices were unified
           for (unsigned int i = 0; i < cell->line(line)->n_active_fe_indices();
                ++i)
             for (unsigned int j = i + 1;
index 65738b2d5eea57b7b193deddb211fef7060cef21..5b92cb53b375cde5b285154dd0635af10fe15abd 100644 (file)
@@ -16,8 +16,8 @@
 
 
 // if the mesh is generated after the hp::DoFHandler is attached to the
-// triangulation object, then we can't set active fe indices -- which is
-// somewhat tragic since we have to assign active fe indices before we can
+// triangulation object, then we can't set active FE indices -- which is
+// somewhat tragic since we have to assign active FE indices before we can
 // call distribute_dofs
 //
 // originally, this problem was avoided because the hp::DoFHandler listens to
index 552b933545b307aabd7055ab9a7fa764762ede04..99ff83b956805df16b149c2e4eebb9e158633e8f 100644 (file)
@@ -63,7 +63,7 @@ test()
   DoFHandler<2> hp_dof_handler(triangulation);
   DoFHandler<2> hp_dof_handler2(triangulation);
 
-  // set different fe for testing
+  // set different FE for testing
   DoFHandler<2>::active_cell_iterator cell = hp_dof_handler.begin_active(),
                                       endc = hp_dof_handler.end();
 
index 849c51c0abf9da31df74b760f7db7d99e88af3a2..ed1a30607450abf436a581346ee136d06be7520e 100644 (file)
@@ -15,7 +15,7 @@
 
 
 /* clang-format off */
-// find the least dominating fe from a set of fes on faces (codim=1).
+// find the least dominating FE from a set of FEs on faces (codim=1).
 // for this task we concatenate the two functions
 // FECollection::find_common_subspace() and FECollection::find_dominated_fe().
 // we test the results for the following collections:
index b94031894410feb2ce001cf8033be9a978de7135..d833d549f431ae6ef94eaf3bb6dc69ffdb1bf299 100644 (file)
@@ -15,7 +15,7 @@
 
 
 /* clang-format off */
-// find the most dominating fe from a set of fes on faces (codim=1).
+// find the most dominating FE from a set of FEs on faces (codim=1).
 // for this task we concatenate the two functions
 // FECollection::find_encapsulating_space() and FECollection::find_dominating_fe().
 // we test the results for the following collections:
index 185421afa4ece49f6937e56bf7074b9b3dff7d27..7ccf54c407388dc44db3495844a1b23d710def61 100644 (file)
@@ -35,7 +35,7 @@ test()
 
   while (fe_collection.size() < 3)
     {
-      // add dummy fe to collection
+      // add dummy FE to collection
       fe_collection.push_back(FE_Q<dim>(1));
       deallog << "size:" << fe_collection.size() << std::endl;
 
index f358edcb47984e977270914c433473b920c1f6e5..0f8c1734cec7c1fc3e5b59763240aa25afc61124 100644 (file)
@@ -15,7 +15,7 @@
 
 
 
-// check if future fe indices will be set correctly
+// check if future FE indices will be set correctly
 
 
 #include <deal.II/dofs/dof_handler.h>
index 800f4283880ced44bb891b3a2f8d2ca7cd2a55fd..9a1b361bc64da7657fb7531bb1c723580c11a2f8 100644 (file)
@@ -2,12 +2,12 @@
 DEAL::Yes, exception 1!
 DEAL::ExcMessage( "For DoFHandler objects in hp-mode, finite elements are only " "associated with active cells. Consequently, you can not ask " "for the active finite element on cells with children.")
 DEAL::Yes, exception 2!
-DEAL::ExcMessage( "You cannot call this function on non-active cells " "of DoFHandler objects unless you provide an explicit " "finite element index because they do not have naturally " "associated finite element spaces associated: degrees " "of freedom are only distributed on active cells for which " "the active_fe_index has been set.")
+DEAL::ExcMessage( "You cannot call this function on non-active cells " "of DoFHandler objects unless you provide an explicit " "finite element index because they do not have naturally " "associated finite element spaces associated: degrees " "of freedom are only distributed on active cells for which " "the active FE index has been set.")
 DEAL::Yes, exception 1!
 DEAL::ExcMessage( "For DoFHandler objects in hp-mode, finite elements are only " "associated with active cells. Consequently, you can not ask " "for the active finite element on cells with children.")
 DEAL::Yes, exception 2!
-DEAL::ExcMessage( "You cannot call this function on non-active cells " "of DoFHandler objects unless you provide an explicit " "finite element index because they do not have naturally " "associated finite element spaces associated: degrees " "of freedom are only distributed on active cells for which " "the active_fe_index has been set.")
+DEAL::ExcMessage( "You cannot call this function on non-active cells " "of DoFHandler objects unless you provide an explicit " "finite element index because they do not have naturally " "associated finite element spaces associated: degrees " "of freedom are only distributed on active cells for which " "the active FE index has been set.")
 DEAL::Yes, exception 1!
 DEAL::ExcMessage( "For DoFHandler objects in hp-mode, finite elements are only " "associated with active cells. Consequently, you can not ask " "for the active finite element on cells with children.")
 DEAL::Yes, exception 2!
-DEAL::ExcMessage( "You cannot call this function on non-active cells " "of DoFHandler objects unless you provide an explicit " "finite element index because they do not have naturally " "associated finite element spaces associated: degrees " "of freedom are only distributed on active cells for which " "the active_fe_index has been set.")
+DEAL::ExcMessage( "You cannot call this function on non-active cells " "of DoFHandler objects unless you provide an explicit " "finite element index because they do not have naturally " "associated finite element spaces associated: degrees " "of freedom are only distributed on active cells for which " "the active FE index has been set.")
index 10918f767c7ea07031fae9692ea815abded00a2a..ccd669d8c21b2e73fe9ef966566d02b2de06c1ed 100644 (file)
@@ -369,7 +369,7 @@ test_interpolation_base(const hp::FECollection<dim> &    fe,
         deallog << "Testing " << fe[fe1].get_name() << " vs. "
                 << fe[fe2].get_name() << std::endl;
 
-        // set fe on coarse cell to 'i', on
+        // set FE on coarse cell to 'i', on
         // all fine cells to 'j'
         typename DoFHandler<dim>::active_cell_iterator cell =
           dof_handler.begin_active();
index d94968f37785ff911abaa2b686bcd5d0136ed193..7c6ecca2d206bbe75b3c1b94e2c1048e90551ad8 100644 (file)
@@ -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 <deal.II/base/function.h>
 #include <deal.II/base/function_lib.h>
@@ -365,7 +365,7 @@ test_interpolation_base(const hp::FECollection<dim> &    fe,
         deallog << "Testing " << fe[fe1].get_name() << " vs. "
                 << fe[fe2].get_name() << std::endl;
 
-        // set fe on coarse cell to 'i', on
+        // set FE on coarse cell to 'i', on
         // all fine cells to 'j'
         typename DoFHandler<dim>::active_cell_iterator cell =
           dof_handler.begin_active();
index 002975d150a87dcec7e22dac057e6680feadd47a..296e69e7c013fe582fc2be44a49f0d6c2c9d217d 100644 (file)
@@ -72,7 +72,7 @@ test(const bool apply_constrains, const unsigned int hp)
   AffineConstraints<double> constraints; // for boundary conditions
 
 
-  // populate fe system:
+  // populate FE system:
   fe.push_back(FE_Q_Hierarchical<dim>(2));
   fe.push_back(FE_Q_Hierarchical<dim>(4));
 
@@ -82,7 +82,7 @@ test(const bool apply_constrains, const unsigned int hp)
   cell->set_active_fe_index(1);
 
   // need to distribute dofs before refinement,
-  // otherwise active fe index will not transfer to child cells
+  // otherwise active FE index will not transfer to child cells
   dof_handler.distribute_dofs(fe);
 
   // refine first cell (simple case)
index bb0ad7026b6443f3a7616ba662944da71586ed1f..8261d15a45f427e2d8805595fef932587eba99cd 100644 (file)
@@ -166,7 +166,7 @@ diffusionMechanics<dim>::cell_is_in_omega2_domain(
   return (cell->material_id() == omega2_domain_id);
 }
 
-// Set active fe indices in each sub-domain
+// Set active FE indices in each sub-domain
 template <int dim>
 void
 diffusionMechanics<dim>::set_active_fe_indices()
index 756c5aceeffdbf4e7ab848f6e73cb12a29a2eaba..56374fc6bc4e4bdd5f3cec212fff2f25aac2352b 100644 (file)
@@ -15,7 +15,7 @@
 
 
 
-// like hp/matrices, but with different fe objects
+// like hp/matrices, but with different FE objects
 
 
 #include <deal.II/base/function_lib.h>
index 667cf574ea6b0f572f22ac0300852ec8496d6506..891621068c1d93cb032f2a2121b49244fe63258c 100644 (file)
@@ -57,7 +57,7 @@ setup(Triangulation<dim> &tria, const DoFHandler<dim> &dh)
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  // Set all active fe indices to 1.
+  // Set all active FE indices to 1.
   // Flag first half of cells for refinement, and the other half for coarsening.
   typename DoFHandler<dim>::cell_iterator cell = dh.begin(1), endc = dh.end(1);
   for (unsigned int counter = 0; cell != endc; ++counter, ++cell)
index f015a4b738961d31d93719a56116f9e3d145169d..6016701313b28e5d5caff1fd356e89f8ffa4c1b1 100644 (file)
@@ -57,7 +57,7 @@ setup(Triangulation<dim> &tria, const DoFHandler<dim> &dh)
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  // Set all active fe indices to 1.
+  // Set all active FE indices to 1.
   // Flag first half of cells for refinement, and the other half for coarsening.
   typename DoFHandler<dim>::cell_iterator cell = dh.begin(1), endc = dh.end(1);
   for (unsigned int counter = 0; cell != endc; ++counter, ++cell)
index f8e66eb71ea280eaa9484daea33a162bcd84d42b..1bdd24940acb4ec86a3a83c271d99dadabaae165 100644 (file)
@@ -57,7 +57,7 @@ setup(Triangulation<dim> &tria, const DoFHandler<dim> &dh)
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  // Set all active fe indices to 1.
+  // Set all active FE indices to 1.
   // Flag first half of cells for refinement, and the other half for coarsening.
   typename DoFHandler<dim>::cell_iterator cell = dh.begin(1), endc = dh.end(1);
   for (unsigned int counter = 0; cell != endc; ++counter, ++cell)
index c9f6584ba17d506fc694b6626cad9e442c7c3464..8948f2b2773969019452e500e945925cf262a86a 100644 (file)
@@ -57,7 +57,7 @@ setup(Triangulation<dim> &tria, const DoFHandler<dim> &dh)
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  // Set all active fe indices to 1.
+  // Set all active FE indices to 1.
   // Flag first half of cells for refinement, and the other half for coarsening.
   typename DoFHandler<dim>::cell_iterator cell = dh.begin(1), endc = dh.end(1);
   for (unsigned int counter = 0; cell != endc; ++counter, ++cell)
index e9dcdc5e18678daaecf71a7860145d0c84a6b7f4..d90956c457a3f367e4014aa69aaa56180a8dfc0b 100644 (file)
@@ -57,7 +57,7 @@ setup(Triangulation<dim> &tria, const DoFHandler<dim> &dh)
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  // Set all active fe indices to 1.
+  // Set all active FE indices to 1.
   // Flag first half of cells for refinement, and the other half for coarsening.
   typename DoFHandler<dim>::cell_iterator cell = dh.begin(1), endc = dh.end(1);
   for (unsigned int counter = 0; cell != endc; ++counter, ++cell)
index 8bf7e1de3a4e04a741c8f739083f13fbe244e469..1587a86d4a732f7b0e857d7108c28495fdcfda23 100644 (file)
@@ -57,7 +57,7 @@ setup(Triangulation<dim> &tria, const DoFHandler<dim> &dh)
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  // Set all active fe indices to 1.
+  // Set all active FE indices to 1.
   // Flag first half of cells for refinement, and the other half for coarsening.
   typename DoFHandler<dim>::cell_iterator cell = dh.begin(1), endc = dh.end(1);
   for (unsigned int counter = 0; cell != endc; ++counter, ++cell)
index 53aab49f803df1cca99a2e4126290c26997e381a..eb87fd9e7f7afa2d1b6d9ec98919bcdcc6aba44c 100644 (file)
@@ -57,7 +57,7 @@ setup(Triangulation<dim> &tria, const DoFHandler<dim> &dh)
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  // Set all active fe indices to 1.
+  // Set all active FE indices to 1.
   // Flag first half of cells for refinement, and the other half for coarsening.
   typename DoFHandler<dim>::cell_iterator cell = dh.begin(1), endc = dh.end(1);
   for (unsigned int counter = 0; cell != endc; ++counter, ++cell)
index e85848631590ac335a5fadc61e0307266306045d..8d7bb2cf973fe963d77cd652e959d99f664e478a 100644 (file)
@@ -57,7 +57,7 @@ test()
 
   for (cell = dh.begin_active(); cell != dh.end(); ++cell)
     {
-      // set active fe index
+      // set active FE index
       if (i >= fe_collection.size())
         i = 0;
       cell->set_active_fe_index(i++);
index a305d959e2aab8e7fba0c82959328a27afc5e3e4..db079c63abb67f7ea4db58d69ec9b209368a2291 100644 (file)
@@ -2,12 +2,12 @@
 DEAL::Yes, exception 1!
 DEAL::ExcMessage( "For DoFHandler objects in hp-mode, finite elements are only " "associated with active cells. Consequently, you can not ask " "for the active finite element on cells with children.")
 DEAL::Yes, exception!
-DEAL::ExcMessage( "You cannot call this function on non-active cells " "of DoFHandler objects unless you provide an explicit " "finite element index because they do not have naturally " "associated finite element spaces associated: degrees " "of freedom are only distributed on active cells for which " "the active_fe_index has been set.")
+DEAL::ExcMessage( "You cannot call this function on non-active cells " "of DoFHandler objects unless you provide an explicit " "finite element index because they do not have naturally " "associated finite element spaces associated: degrees " "of freedom are only distributed on active cells for which " "the active FE index has been set.")
 DEAL::Yes, exception 1!
 DEAL::ExcMessage( "For DoFHandler objects in hp-mode, finite elements are only " "associated with active cells. Consequently, you can not ask " "for the active finite element on cells with children.")
 DEAL::Yes, exception!
-DEAL::ExcMessage( "You cannot call this function on non-active cells " "of DoFHandler objects unless you provide an explicit " "finite element index because they do not have naturally " "associated finite element spaces associated: degrees " "of freedom are only distributed on active cells for which " "the active_fe_index has been set.")
+DEAL::ExcMessage( "You cannot call this function on non-active cells " "of DoFHandler objects unless you provide an explicit " "finite element index because they do not have naturally " "associated finite element spaces associated: degrees " "of freedom are only distributed on active cells for which " "the active FE index has been set.")
 DEAL::Yes, exception 1!
 DEAL::ExcMessage( "For DoFHandler objects in hp-mode, finite elements are only " "associated with active cells. Consequently, you can not ask " "for the active finite element on cells with children.")
 DEAL::Yes, exception!
-DEAL::ExcMessage( "You cannot call this function on non-active cells " "of DoFHandler objects unless you provide an explicit " "finite element index because they do not have naturally " "associated finite element spaces associated: degrees " "of freedom are only distributed on active cells for which " "the active_fe_index has been set.")
+DEAL::ExcMessage( "You cannot call this function on non-active cells " "of DoFHandler objects unless you provide an explicit " "finite element index because they do not have naturally " "associated finite element spaces associated: degrees " "of freedom are only distributed on active cells for which " "the active FE index has been set.")
index f0c510bf82a16f3aaa76bb905387038198457ecd..a7b06b577e27a6c901710ca56130816448767842 100644 (file)
@@ -15,7 +15,7 @@
 
 
 
-// Like _07 but with all same fe indices. This triggered yet another place
+// Like _07 but with all same FE indices. This triggered yet another place
 // where we had the same kind of error.
 
 #include <deal.II/dofs/dof_handler.h>
index d68a6b57ccf8f672acf30f62729cb6463e3148e2..21b47fa2a9865d2be2191813d57ca1cb8ec7385f 100644 (file)
@@ -285,7 +285,7 @@ main()
 
           constraints.print(logfile);
 
-          // release fe
+          // release FE
           dof.clear();
 
           deallog << std::endl;
index 96984b02253b93bee56ea67a7697906e3264f295..2c1242c7345324dfb973530ae0e4f41860ee790d 100644 (file)
@@ -66,7 +66,7 @@ test()
   DoFHandler<dim> dh(tria);
   for (const auto &cell : dh.active_cell_iterators())
     {
-      // set active fe index
+      // set active FE index
       if (cell->is_locally_owned())
         cell->set_active_fe_index(1);
     }
index 8b04903b90d132128c5f72b9f2795d3927d18a9b..0f2bfd5ce75cd4a4dbf5f3ea51387e83d40de5b8 100644 (file)
@@ -15,7 +15,7 @@
 
 
 
-// active fe indices transfer on refinement
+// active FE indices transfer on refinement
 
 
 #include <deal.II/distributed/tria.h>
@@ -55,7 +55,7 @@ test()
   for (auto &cell : dh.active_cell_iterators())
     if (cell->is_locally_owned())
       {
-        // set active fe index
+        // set active FE index
         if (!(cell->is_artificial()))
           {
             if (i >= fe_collection.size())
index e23bf012d1659f35072c29f72a92c5ac47e4cf20..7840535abf8e30d1c0eaa07af65a101aa9b685f0 100644 (file)
@@ -15,7 +15,7 @@
 
 
 
-// active fe indices transfer on serialization
+// active FE indices transfer on serialization
 
 
 #include <deal.II/distributed/tria.h>
@@ -54,7 +54,7 @@ test()
     for (auto &cell : dh.active_cell_iterators())
       if (cell->is_locally_owned())
         {
-          // set active fe index
+          // set active FE index
           if (!(cell->is_artificial()))
             {
               if (i >= fe_collection.size())
index ea74872e768e5514f995059e0c2072133fb572e0..d4716c39a2a775eef0fbf95f47ce247d00a75855 100644 (file)
@@ -15,7 +15,7 @@
 
 
 
-// active fe indices transfer on repartitioning
+// active FE indices transfer on repartitioning
 
 
 #include <deal.II/distributed/cell_weights.h>
@@ -54,7 +54,7 @@ test()
   for (auto &cell : dh.active_cell_iterators())
     if (cell->is_locally_owned())
       {
-        // set active fe index
+        // set active FE index
         if (!(cell->is_artificial()))
           cell->set_active_fe_index(myid);
 
index 1d5b2c60206ccbfee91f85b67cf684aa57b25b0e..0d2f747b7d2d06bc0b256b3e677e9f36a54af530 100644 (file)
@@ -15,7 +15,7 @@
 
 
 
-// active fe indices serialization with a different number of cpus
+// active FE indices serialization with a different number of cpus
 
 
 #include <deal.II/distributed/tria.h>
@@ -63,7 +63,7 @@ test()
       for (auto &cell : dh.active_cell_iterators())
         if (cell->is_locally_owned())
           {
-            // set active fe index
+            // set active FE index
             if (i >= fe_collection.size())
               i = 0;
             cell->set_active_fe_index(i++);
index 75781fa08eb42dfe265691c84ff7b4f2604dd61e..b37045a17dded17c39ffa946b6a3efac62679033 100644 (file)
@@ -84,7 +84,7 @@ test(const unsigned int degree_center,
   for (const auto &cell : dh.active_cell_iterators())
     if (cell->is_locally_owned() && cell->id().to_string() == "1_0:")
       {
-        // set different fe on center cell
+        // set different FE on center cell
         cell->set_active_fe_index(1);
 
 #ifdef DEBUG
index 549afd01a58adb60d87b3f93c4671f8ee8e33140..ab40d3f1dbb9d489869885a2edcfb3c7ed602d51 100644 (file)
@@ -84,7 +84,7 @@ test(const unsigned int degree_center,
   for (const auto &cell : dh.active_cell_iterators())
     if (cell->is_locally_owned() && cell->id().to_string() == "1_0:")
       {
-        // set different fe on center cell
+        // set different FE on center cell
         cell->set_active_fe_index(1);
 
 #ifdef DEBUG
index f43bde70566e0cd94be2cd25246f46789e8301b3..d547d16f6b1516ec42b7edf0cd6b6b365c1ffcfc 100644 (file)
@@ -86,7 +86,7 @@ test(const unsigned int degree_center,
       {
         if (cell->id().to_string() == "1_0:")
           {
-            // set different fe on center cell
+            // set different FE on center cell
             cell->set_active_fe_index(1);
 
 #ifdef DEBUG
index 15d2d6b329f8a813df6f2c5e2eb7a3af8e5e7208..65e63017e10bd8fb28d3a243b84963de56cab174 100644 (file)
@@ -73,7 +73,7 @@ test()
 
       if (cell->is_locally_owned())
         {
-          // set active fe index
+          // set active FE index
           if (i >= fe_collection.size())
             i = 0;
           cell->set_active_fe_index(i++);
index f63ecf6b1fce3344e9e72c47c0a6b7d18b9f73c5..665aec2124f6a92ab5c91c13bd398a7a686576fd 100644 (file)
@@ -73,7 +73,7 @@ test()
 
       if (cell->is_locally_owned())
         {
-          // set active fe index
+          // set active FE index
           if (i >= fe_collection.size())
             i = 0;
           cell->set_active_fe_index(i++);
index 08050fe34554a2dc81bee32d1ebf88533c2cff3c..7c633d66a0af2b331cb3f29474f13f0a0622a4f9 100644 (file)
@@ -16,7 +16,7 @@
 
 // This test provides a hp::DoFHandler with two FE_Q(2) elements
 // assigned on a p::d::Triangulation consisting of 64x64 cells, on which
-// active fe indices are mostly randomly distributed. This DoF
+// active FE indices are mostly randomly distributed. This DoF
 // distribution test repeats for an increasing amount of processors.
 //
 // At some point, this test failed to provide a consistent number of
index fe8a8eff9ece0a6c12db5d3faf3e49154598da63..4c9f51485dd572e8460f3484f2dd00d9cff7072d 100644 (file)
@@ -66,7 +66,7 @@ setup(Triangulation<dim> &tria, const DoFHandler<dim> &dh)
   GridGenerator::subdivided_hyper_cube(tria, 4);
   Assert(tria.n_cells(0) == tria.n_global_active_cells(), ExcInternalError());
 
-  // Set all active fe indices to 1.
+  // Set all active FE indices to 1.
   // Flag first half of cells for refinement, and the other half for coarsening.
   for (const auto &cell : dh.active_cell_iterators())
     if (!cell->is_artificial() && cell->is_locally_owned())
index 1353091daf13b26212ecbaf96fd6864a85ab8287..c87a31fc165e37622de130f2308d3f6a70534c7d 100644 (file)
@@ -61,7 +61,7 @@ test()
     {
       if (cell->is_locally_owned())
         {
-          // set active fe index
+          // set active FE index
           if (!(cell->is_artificial()))
             {
               if (i >= fe_collection.size())
index ea18d6330916e11ead69e513f2b23cf388dfa32d..51660817446053c954836dd7b0e82d43f3792eeb 100644 (file)
@@ -60,7 +60,7 @@ test()
 
   DoFHandler<dim> dgq_dof_handler(tria);
 
-  // randomly assign fes
+  // randomly assign FEs
   for (const auto &cell : dgq_dof_handler.active_cell_iterators())
     if (cell->is_locally_owned())
       cell->set_active_fe_index(Testing::rand() % max_degree);
index 966597fba33694e457687e813d5b4e3243283de4..a86447029960198fb49b4b88de8039522dfb3e2d 100644 (file)
@@ -266,7 +266,7 @@ test_with_hanging_nodes(const FiniteElement<dim> &fe, const unsigned int p)
 }
 
 
-// same as above but for multiple fes
+// same as above but for multiple FEs
 template <int fe_degree, int n_q_points_1d, int dim>
 void
 test_with_hanging_nodes(const std::vector<const FiniteElement<dim> *> &fes,

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.