]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Cleanup DoFTools hp::DoFhandler 10558/head
authorDaniel Arndt <arndtd@ornl.gov>
Mon, 8 Jun 2020 16:15:54 +0000 (12:15 -0400)
committerDaniel Arndt <arndtd@ornl.gov>
Fri, 19 Jun 2020 17:39:31 +0000 (13:39 -0400)
include/deal.II/dofs/dof_tools.h
include/deal.II/fe/fe_tools_interpolate.templates.h
include/deal.II/multigrid/mg_constrained_dofs.h
include/deal.II/numerics/vector_tools_boundary.templates.h
source/dofs/dof_handler_policy.cc
source/dofs/dof_tools.cc
source/dofs/dof_tools_constraints.cc
source/dofs/dof_tools_sparsity.cc
source/multigrid/mg_tools.cc

index 05c3b2f057920dc326c543c586fe2f279142ad82..58a1d760c01e5475e235b62a1c89a3da1d862c08 100644 (file)
@@ -305,131 +305,6 @@ namespace DoFTools
    * @}
    */
 
-  /**
-   * @name Generic Functions
-   *
-   * Functions to support code that generically uses both DoFHandler and
-   * hp::DoFHandler.
-   * @{
-   */
-  /**
-   * Maximal number of degrees of freedom on a cell.
-   *
-   * @deprecated Use <code>dh.get_fe_collection().max_dofs_per_cell()</code>.
-   *
-   * @relatesalso DoFHandler
-   */
-  template <int dim, int spacedim>
-  DEAL_II_DEPRECATED unsigned int
-  max_dofs_per_cell(const DoFHandler<dim, spacedim> &dh);
-
-
-  /**
-   * Maximal number of degrees of freedom on a face.
-   *
-   * This function exists for both non-hp and hp DoFHandlers, to allow for a
-   * uniform interface to query this property.
-   *
-   * @deprecated Use <code>dh.get_fe_collection().max_dofs_per_face()</code>.
-   *
-   * @relatesalso DoFHandler
-   */
-  template <int dim, int spacedim>
-  DEAL_II_DEPRECATED unsigned int
-  max_dofs_per_face(const DoFHandler<dim, spacedim> &dh);
-
-  /**
-   * Maximal number of degrees of freedom on a vertex.
-   *
-   * This function exists for both non-hp and hp DoFHandlers, to allow for a
-   * uniform interface to query this property.
-   *
-   * @deprecated Use <code>dh.get_fe_collection().max_dofs_per_vertex()</code>.
-   *
-   * @relatesalso DoFHandler
-   */
-  template <int dim, int spacedim>
-  DEAL_II_DEPRECATED unsigned int
-  max_dofs_per_vertex(const DoFHandler<dim, spacedim> &dh);
-
-  /**
-   * Maximal number of degrees of freedom on a vertex.
-   *
-   * This function exists for both non-hp and hp DoFHandlers, to allow for a
-   * uniform interface to query this property.
-   *
-   * @deprecated Use <code>dh.get_fe_collection().max_dofs_per_vertex()</code>.
-   *
-   * @relatesalso hp::DoFHandler
-   */
-  template <int dim, int spacedim>
-  DEAL_II_DEPRECATED unsigned int
-  max_dofs_per_vertex(const DoFHandler<dim, spacedim> &dh);
-
-  /**
-   * Number of vector components in the finite element object used by this
-   * DoFHandler.
-   *
-   * This function exists for both non-hp and hp DoFHandlers, to allow for a
-   * uniform interface to query this property.
-   *
-   * @deprecated Use <code>dh.get_fe_collection().n_components()</code>.
-   *
-   * @relatesalso DoFHandler
-   */
-  template <int dim, int spacedim>
-  DEAL_II_DEPRECATED unsigned int
-  n_components(const DoFHandler<dim, spacedim> &dh);
-
-  /**
-   * Number of vector components in the finite element object used by this
-   * DoFHandler.
-   *
-   * This function exists for both non-hp and hp DoFHandlers, to allow for a
-   * uniform interface to query this property.
-   *
-   * @deprecated Use <code>dh.get_fe_collection().n_components()</code>.
-   *
-   * @relatesalso hp::DoFHandler
-   */
-  template <int dim, int spacedim>
-  DEAL_II_DEPRECATED unsigned int
-  n_components(const DoFHandler<dim, spacedim> &dh);
-
-  /**
-   * Find out whether the first FiniteElement used by this DoFHandler is
-   * primitive or not.
-   *
-   * This function exists for both non-hp and hp DoFHandlers, to allow for a
-   * uniform interface to query this property.
-   *
-   * @deprecated Use <code>dh.get_fe(0).is_primitive()</code>.
-   *
-   * @relatesalso DoFHandler
-   */
-  template <int dim, int spacedim>
-  DEAL_II_DEPRECATED bool
-  fe_is_primitive(const DoFHandler<dim, spacedim> &dh);
-
-  /**
-   * Find out whether the first FiniteElement used by this DoFHandler is
-   * primitive or not.
-   *
-   * This function exists for both non-hp and hp DoFHandlers, to allow for a
-   * uniform interface to query this property.
-   *
-   * @deprecated Use <code>dh.get_fe(0).is_primitive()</code>.
-   *
-   * @relatesalso hp::DoFHandler
-   */
-  template <int dim, int spacedim>
-  DEAL_II_DEPRECATED bool
-  fe_is_primitive(const DoFHandler<dim, spacedim> &dh);
-
-  /**
-   * @}
-   */
-
   /**
    * @name Sparsity pattern generation
    * @{
@@ -1740,22 +1615,6 @@ namespace DoFTools
                          const types::subdomain_id subdomain_id,
                          std::vector<bool> &       selected_dofs);
 
-
-  /**
-   * Extract the set of global DoF indices that are owned by the current
-   * processor. For regular DoFHandler objects, this set is the complete set
-   * with all DoF indices. In either case, it equals what
-   * DoFHandler::locally_owned_dofs() returns.
-   *
-   * @deprecated Use DoFHandler::locally_owned_dofs() directly instead of this
-   * function.
-   */
-  template <typename DoFHandlerType>
-  DEAL_II_DEPRECATED void
-  extract_locally_owned_dofs(const DoFHandlerType &dof_handler,
-                             IndexSet &            dof_set);
-
-
   /**
    * Extract the set of global DoF indices that are active on the current
    * DoFHandler. For regular DoFHandlers, these are all DoF indices, but for
@@ -2820,62 +2679,6 @@ namespace DoFTools
 
   // ---------------------- inline and template functions --------------------
 
-  template <int dim, int spacedim>
-  inline unsigned int
-  max_dofs_per_cell(const DoFHandler<dim, spacedim> &dh)
-  {
-    if (dh.hp_capability_enabled == true)
-      return dh.get_fe_collection().max_dofs_per_cell();
-    else
-      return dh.get_fe().dofs_per_cell;
-  }
-
-
-  template <int dim, int spacedim>
-  inline unsigned int
-  max_dofs_per_face(const DoFHandler<dim, spacedim> &dh)
-  {
-    if (dh.hp_capability_enabled == true)
-      return dh.get_fe_collection().max_dofs_per_face();
-    else
-      return dh.get_fe().dofs_per_face;
-  }
-
-
-  template <int dim, int spacedim>
-  inline unsigned int
-  max_dofs_per_vertex(const DoFHandler<dim, spacedim> &dh)
-  {
-    if (dh.hp_capability_enabled == true)
-      return dh.get_fe_collection().max_dofs_per_vertex();
-    else
-      return dh.get_fe().dofs_per_vertex;
-  }
-
-
-  template <int dim, int spacedim>
-  inline unsigned int
-  n_components(const DoFHandler<dim, spacedim> &dh)
-  {
-    if (dh.hp_capability_enabled == true)
-      return dh.get_fe(0).n_components();
-    else
-      return dh.get_fe().n_components();
-  }
-
-
-
-  template <int dim, int spacedim>
-  inline bool
-  fe_is_primitive(const DoFHandler<dim, spacedim> &dh)
-  {
-    if (dh.hp_capability_enabled == true)
-      return dh.get_fe(0).is_primitive();
-    else
-      return dh.get_fe().is_primitive();
-  }
-
-
   template <typename DoFHandlerType, class Comp>
   void
   map_support_points_to_dofs(
index f89a3966405eb06011ed9b42599fb41a7531d239..01a278f9f8a1767ddd678b2e2e1e800049d936df 100644 (file)
@@ -120,9 +120,9 @@ namespace FETools
     // this does not lead to
     // reallocation of memory
     Vector<typename OutVector::value_type> u1_local(
-      DoFTools::max_dofs_per_cell(dof1));
+      dof1.get_fe_collection().max_dofs_per_cell());
     Vector<typename OutVector::value_type> u2_local(
-      DoFTools::max_dofs_per_cell(dof2));
+      dof2.get_fe_collection().max_dofs_per_cell());
 
     // have a map for interpolation matrices.
     // Using a unique_ptr makes sure that the
@@ -141,7 +141,7 @@ namespace FETools
     (void)endc2;
 
     std::vector<types::global_dof_index> dofs;
-    dofs.reserve(DoFTools::max_dofs_per_cell(dof2));
+    dofs.reserve(dof2.get_fe_collection().max_dofs_per_cell());
 
     u2 = typename OutVector::value_type(0.);
     OutVector touch_count(u2);
@@ -296,9 +296,9 @@ namespace FETools
 #endif
 
     Vector<typename OutVector::value_type> u1_local(
-      DoFTools::max_dofs_per_cell(dof1));
+      dof1.get_fe_collection().max_dofs_per_cell());
     Vector<typename OutVector::value_type> u1_int_local(
-      DoFTools::max_dofs_per_cell(dof1));
+      dof1.get_fe_collection().max_dofs_per_cell());
 
     const types::subdomain_id subdomain_id =
       dof1.get_triangulation().locally_owned_subdomain();
index d038e76e711217d9979b7cb0ca08f36f40bbf5cf..d60ac04867d885483436a6fc7149d503254002e7 100644 (file)
@@ -388,7 +388,7 @@ MGConstrainedDoFs::make_no_normal_flux_constraints(
 {
   // For a given boundary id, find which vector component is on the boundary
   // and set a zero boundary constraint for those degrees of freedom.
-  const unsigned int n_components = DoFTools::n_components(dof);
+  const unsigned int n_components = dof.get_fe_collection().n_components();
   AssertIndexRange(first_vector_component + dim - 1, n_components);
 
   ComponentMask comp_mask(n_components, false);
index a2b39b271edc331fa61e2ddd14c9d787825ab458..7c471864d9e97077c53bdcf4718a067cb22ab557 100644 (file)
@@ -80,7 +80,7 @@ namespace VectorTools
              ExcMessage("You cannot specify the special boundary indicator "
                         "for interior faces in your function map."));
 
-      const unsigned int n_components = DoFTools::n_components(dof);
+      const unsigned int n_components = dof.get_fe_collection().n_components();
       for (typename std::map<types::boundary_id,
                              const Function<spacedim, number> *>::const_iterator
              i = function_map.begin();
@@ -147,15 +147,17 @@ namespace VectorTools
 
           // field to store the indices
           std::vector<types::global_dof_index> face_dofs;
-          face_dofs.reserve(DoFTools::max_dofs_per_face(dof));
+          face_dofs.reserve(dof.get_fe_collection().max_dofs_per_face());
 
           // array to store the values of the boundary function at the boundary
           // points. have two arrays for scalar and vector functions to use the
           // more efficient one respectively
           std::vector<number>         dof_values_scalar;
           std::vector<Vector<number>> dof_values_system;
-          dof_values_scalar.reserve(DoFTools::max_dofs_per_face(dof));
-          dof_values_system.reserve(DoFTools::max_dofs_per_face(dof));
+          dof_values_scalar.reserve(
+            dof.get_fe_collection().max_dofs_per_face());
+          dof_values_system.reserve(
+            dof.get_fe_collection().max_dofs_per_face());
 
           // before we start with the loop over all cells create an hp::FEValues
           // object that holds the interpolation points of all finite elements
index 6d5ac2be5b9f8845711dfea8a05ad6cebde6784b..381b1a78f4aba9b6ba83764f24cb2ded0249e030 100644 (file)
@@ -2923,7 +2923,8 @@ namespace internal
           std::vector<types::subdomain_id> subdomain_association(
             n_dofs, numbers::invalid_subdomain_id);
           std::vector<types::global_dof_index> local_dof_indices;
-          local_dof_indices.reserve(DoFTools::max_dofs_per_cell(dof_handler));
+          local_dof_indices.reserve(
+            dof_handler.get_fe_collection().max_dofs_per_cell());
 
           // loop over all cells and record which subdomain a DoF belongs to.
           // give to the smaller subdomain_id in case it is on an interface
@@ -2986,7 +2987,8 @@ namespace internal
           std::vector<types::subdomain_id> level_subdomain_association(
             n_dofs_on_level, numbers::invalid_subdomain_id);
           std::vector<types::global_dof_index> local_dof_indices;
-          local_dof_indices.reserve(DoFTools::max_dofs_per_cell(dof_handler));
+          local_dof_indices.reserve(
+            dof_handler.get_fe_collection().max_dofs_per_cell());
 
           // loop over all cells and record which subdomain a DoF belongs to.
           // interface goes to proccessor with smaller subdomain id
index a3d55e927519a9bfd02b175f7c627cecb4ff0261..5d42d612494aa2044cb61114c3c46399a190edfb 100644 (file)
@@ -321,14 +321,19 @@ namespace DoFTools
 
     AssertDimension(cell_data.size(), tria.n_active_cells());
     AssertDimension(dof_data.size(), dof_handler.n_dofs());
-    AssertIndexRange(component, n_components(dof_handler));
-    Assert(fe_is_primitive(dof_handler) == true,
-           typename FiniteElement<dim>::ExcFENotPrimitive());
+    const auto &fe_collection = dof_handler.get_fe_collection();
+    AssertIndexRange(component, fe_collection.n_components());
+    for (unsigned int i = 0; i < fe_collection.size(); ++i)
+      {
+        Assert(fe_collection[i].is_primitive() == true,
+               typename FiniteElement<dim>::ExcFENotPrimitive());
+      }
 
     // store a flag whether we should care about different components. this
     // is just a simplification, we could ask for this at every single
     // place equally well
-    const bool consider_components = (n_components(dof_handler) != 1);
+    const bool consider_components =
+      (dof_handler.get_fe_collection().n_components() != 1);
 
     // zero out the components that we will touch
     if (consider_components == false)
@@ -339,8 +344,7 @@ namespace DoFTools
           dof_handler.n_locally_owned_dofs());
         internal::get_component_association(
           dof_handler,
-          dof_handler.get_fe_collection().component_mask(
-            FEValuesExtractors::Scalar(component)),
+          fe_collection.component_mask(FEValuesExtractors::Scalar(component)),
           component_dofs);
 
         for (unsigned int i = 0; i < dof_data.size(); ++i)
@@ -355,7 +359,7 @@ namespace DoFTools
                                                     dof_handler.begin_active(),
                                                   endc = dof_handler.end();
     std::vector<types::global_dof_index> dof_indices;
-    dof_indices.reserve(max_dofs_per_cell(dof_handler));
+    dof_indices.reserve(fe_collection.max_dofs_per_cell());
 
     for (unsigned int present_cell = 0; cell != endc; ++cell, ++present_cell)
       {
@@ -571,7 +575,8 @@ namespace DoFTools
     const FiniteElement<DoFHandlerType::dimension,
                         DoFHandlerType::space_dimension> &fe = dof.get_fe();
 
-    Assert(component_mask.represents_n_components(n_components(dof)),
+    Assert(component_mask.represents_n_components(
+             dof.get_fe_collection().n_components()),
            ExcMessage(
              "The given component mask is not sized correctly to represent the "
              "components of the given finite element."));
@@ -580,13 +585,15 @@ namespace DoFTools
 
     // two special cases: no component is selected, and all components are
     // selected, both rather stupid, but easy to catch
-    if (component_mask.n_selected_components(n_components(dof)) == 0)
+    if (component_mask.n_selected_components(
+          dof.get_fe_collection().n_components()) == 0)
       {
         std::fill_n(selected_dofs.begin(), dof.n_dofs(level), false);
         return;
       }
-    else if (component_mask.n_selected_components(n_components(dof)) ==
-             n_components(dof))
+    else if (component_mask.n_selected_components(
+               dof.get_fe_collection().n_components()) ==
+             dof.get_fe_collection().n_components())
       {
         std::fill_n(selected_dofs.begin(), dof.n_dofs(level), true);
         return;
@@ -666,7 +673,8 @@ namespace DoFTools
                         IndexSet &                          selected_dofs,
                         const std::set<types::boundary_id> &boundary_ids)
   {
-    Assert(component_mask.represents_n_components(n_components(dof_handler)),
+    Assert(component_mask.represents_n_components(
+             dof_handler.get_fe_collection().n_components()),
            ExcMessage("Component mask has invalid size."));
     Assert(boundary_ids.find(numbers::internal_face_boundary_id) ==
              boundary_ids.end(),
@@ -685,11 +693,13 @@ namespace DoFTools
     // is selected, or all
     const bool check_vector_component =
       ((component_mask.represents_the_all_selected_mask() == false) ||
-       (component_mask.n_selected_components(n_components(dof_handler)) !=
-        n_components(dof_handler)));
+       (component_mask.n_selected_components(
+          dof_handler.get_fe_collection().n_components()) !=
+        dof_handler.get_fe_collection().n_components()));
 
     std::vector<types::global_dof_index> face_dof_indices;
-    face_dof_indices.reserve(max_dofs_per_face(dof_handler));
+    face_dof_indices.reserve(
+      dof_handler.get_fe_collection().max_dofs_per_face());
 
     // now loop over all cells and check whether their faces are at the
     // boundary. note that we need not take special care of single lines
@@ -775,7 +785,8 @@ namespace DoFTools
     std::vector<bool> &                 selected_dofs,
     const std::set<types::boundary_id> &boundary_ids)
   {
-    Assert(component_mask.represents_n_components(n_components(dof_handler)),
+    Assert(component_mask.represents_n_components(
+             dof_handler.get_fe_collection().n_components()),
            ExcMessage("This component mask has the wrong size."));
     Assert(boundary_ids.find(numbers::internal_face_boundary_id) ==
              boundary_ids.end(),
@@ -794,7 +805,8 @@ namespace DoFTools
     selected_dofs.clear();
     selected_dofs.resize(dof_handler.n_dofs(), false);
     std::vector<types::global_dof_index> cell_dof_indices;
-    cell_dof_indices.reserve(max_dofs_per_cell(dof_handler));
+    cell_dof_indices.reserve(
+      dof_handler.get_fe_collection().max_dofs_per_cell());
 
     // now loop over all cells and check whether their faces are at the
     // boundary. note that we need not take special care of single lines
@@ -866,7 +878,8 @@ namespace DoFTools
     };
 
     std::vector<types::global_dof_index> local_dof_indices;
-    local_dof_indices.reserve(max_dofs_per_cell(dof_handler));
+    local_dof_indices.reserve(
+      dof_handler.get_fe_collection().max_dofs_per_cell());
 
     // Get all the dofs that live on the subdomain:
     std::set<types::global_dof_index> predicate_dofs;
@@ -1101,7 +1114,8 @@ namespace DoFTools
     std::fill_n(selected_dofs.begin(), dof_handler.n_dofs(), false);
 
     std::vector<types::global_dof_index> local_dof_indices;
-    local_dof_indices.reserve(max_dofs_per_cell(dof_handler));
+    local_dof_indices.reserve(
+      dof_handler.get_fe_collection().max_dofs_per_cell());
 
     // this function is similar to the make_sparsity_pattern function, see
     // there for more information
@@ -1606,7 +1620,8 @@ namespace DoFTools
                 numbers::invalid_subdomain_id);
 
     std::vector<types::global_dof_index> local_dof_indices;
-    local_dof_indices.reserve(max_dofs_per_cell(dof_handler));
+    local_dof_indices.reserve(
+      dof_handler.get_fe_collection().max_dofs_per_cell());
 
     // loop over all cells and record which subdomain a DoF belongs to.
     // give to the smaller subdomain_id in case it is on an interface
@@ -1679,7 +1694,8 @@ namespace DoFTools
     IndexSet index_set(dof_handler.n_dofs());
 
     std::vector<types::global_dof_index> local_dof_indices;
-    local_dof_indices.reserve(max_dofs_per_cell(dof_handler));
+    local_dof_indices.reserve(
+      dof_handler.get_fe_collection().max_dofs_per_cell());
 
     // first generate an unsorted list of all indices which we fill from
     // the back. could also insert them directly into the IndexSet, but
@@ -2113,7 +2129,7 @@ namespace DoFTools
                    numbers::invalid_dof_index);
 
     std::vector<types::global_dof_index> dofs_on_face;
-    dofs_on_face.reserve(max_dofs_per_face(dof_handler));
+    dofs_on_face.reserve(dof_handler.get_fe_collection().max_dofs_per_face());
     types::global_dof_index next_boundary_index = 0;
 
     // now loop over all cells and check whether their faces are at the
@@ -2164,7 +2180,7 @@ namespace DoFTools
       return;
 
     std::vector<types::global_dof_index> dofs_on_face;
-    dofs_on_face.reserve(max_dofs_per_face(dof_handler));
+    dofs_on_face.reserve(dof_handler.get_fe_collection().max_dofs_per_face());
     types::global_dof_index next_boundary_index = 0;
 
     typename DoFHandlerType::active_cell_iterator cell =
index 6f28fb4829cf8fbf8164b9431e3c54b951be6f7f..708bcaaea73d3afa8fdb2229f7ee7c7a3d3c9bfd 100644 (file)
@@ -3360,17 +3360,17 @@ namespace DoFTools
                       "zero or equal to the number of components in the finite "
                       "element."));
 
-    const unsigned int n_components = DoFTools::n_components(dof);
+    const unsigned int n_components = dof.get_fe_collection().n_components();
 
     Assert(component_mask.n_selected_components(n_components) > 0,
            ComponentMask::ExcNoComponentSelected());
 
     // a field to store the indices on the face
     std::vector<types::global_dof_index> face_dofs;
-    face_dofs.reserve(max_dofs_per_face(dof));
+    face_dofs.reserve(dof.get_fe_collection().max_dofs_per_face());
     // a field to store the indices on the cell
     std::vector<types::global_dof_index> cell_dofs;
-    cell_dofs.reserve(max_dofs_per_cell(dof));
+    cell_dofs.reserve(dof.get_fe_collection().max_dofs_per_cell());
 
     typename DoFHandlerType<dim, spacedim>::active_cell_iterator
       cell = dof.begin_active(),
index a2f31f2198572a243f161b1a3fe30381e565f19b..49cde87a33b1161af609af2d3f30285d34ac8b07 100644 (file)
@@ -88,7 +88,7 @@ namespace DoFTools
              "than the locally owned one does not make sense."));
 
     std::vector<types::global_dof_index> dofs_on_this_cell;
-    dofs_on_this_cell.reserve(max_dofs_per_cell(dof));
+    dofs_on_this_cell.reserve(dof.get_fe_collection().max_dofs_per_cell());
     typename DoFHandlerType::active_cell_iterator cell = dof.begin_active(),
                                                   endc = dof.end();
 
@@ -389,7 +389,7 @@ namespace DoFTools
 #endif
 
     std::vector<types::global_dof_index> dofs_on_this_face;
-    dofs_on_this_face.reserve(max_dofs_per_face(dof));
+    dofs_on_this_face.reserve(dof.get_fe_collection().max_dofs_per_face());
 
     // loop over all faces to check whether they are at a boundary. note
     // that we need not take special care of single lines (using
@@ -489,7 +489,7 @@ namespace DoFTools
 #endif
 
     std::vector<types::global_dof_index> dofs_on_this_face;
-    dofs_on_this_face.reserve(max_dofs_per_face(dof));
+    dofs_on_this_face.reserve(dof.get_fe_collection().max_dofs_per_face());
     typename DoFHandlerType::active_cell_iterator cell = dof.begin_active(),
                                                   endc = dof.end();
     for (; cell != endc; ++cell)
@@ -547,8 +547,8 @@ namespace DoFTools
 
     std::vector<types::global_dof_index> dofs_on_this_cell;
     std::vector<types::global_dof_index> dofs_on_other_cell;
-    dofs_on_this_cell.reserve(max_dofs_per_cell(dof));
-    dofs_on_other_cell.reserve(max_dofs_per_cell(dof));
+    dofs_on_this_cell.reserve(dof.get_fe_collection().max_dofs_per_cell());
+    dofs_on_other_cell.reserve(dof.get_fe_collection().max_dofs_per_cell());
     typename DoFHandlerType::active_cell_iterator cell = dof.begin_active(),
                                                   endc = dof.end();
 
@@ -1100,9 +1100,9 @@ namespace DoFTools
               dof.get_fe_collection();
 
             std::vector<types::global_dof_index> dofs_on_this_cell(
-              DoFTools::max_dofs_per_cell(dof));
+              dof.get_fe_collection().max_dofs_per_cell());
             std::vector<types::global_dof_index> dofs_on_other_cell(
-              DoFTools::max_dofs_per_cell(dof));
+              dof.get_fe_collection().max_dofs_per_cell());
 
             const unsigned int n_components = fe.n_components();
             AssertDimension(int_mask.size(0), n_components);
index f82fdd968212e924f14b097aaa4b975d9d739703..e519ef601baa83ccafcbff10c095128f428c0f68 100644 (file)
@@ -1301,11 +1301,11 @@ namespace MGTools
       if (boundary_indices[i].size() == 0)
         boundary_indices[i] = IndexSet(dof.n_dofs(i));
 
-    const unsigned int n_components = DoFTools::n_components(dof);
+    const unsigned int n_components = dof.get_fe_collection().n_components();
     const bool         fe_is_system = (n_components != 1);
 
     std::vector<types::global_dof_index> local_dofs;
-    local_dofs.reserve(DoFTools::max_dofs_per_face(dof));
+    local_dofs.reserve(dof.get_fe_collection().max_dofs_per_face());
     std::fill(local_dofs.begin(), local_dofs.end(), numbers::invalid_dof_index);
 
     std::vector<std::vector<types::global_dof_index>> dofs_by_level(

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.