]> https://gitweb.dealii.org/ - dealii.git/commitdiff
RCM: Update numerics, part 3: vector_tools
authorMatthias Maier <tamiko@43-1.org>
Sat, 26 May 2018 01:21:29 +0000 (20:21 -0500)
committerMatthias Maier <tamiko@43-1.org>
Wed, 6 Jun 2018 15:19:38 +0000 (10:19 -0500)
include/deal.II/numerics/vector_tools.h
include/deal.II/numerics/vector_tools.templates.h
source/numerics/vector_tools_boundary.inst.in
source/numerics/vector_tools_constraints.inst.in
source/numerics/vector_tools_interpolate.inst.in
source/numerics/vector_tools_project.inst.in
source/numerics/vector_tools_project_codim.inst.in
source/numerics/vector_tools_project_hp.inst.in
source/numerics/vector_tools_project_qp.inst.in
source/numerics/vector_tools_project_qpmf.inst.in
source/numerics/vector_tools_rhs.inst.in

index b6ad27195b0255dfd15c889274a78cc1bc3523d5..8cc2624ff6300cee1d6d544954fcf51d5e91a659 100644 (file)
@@ -58,7 +58,8 @@ namespace hp
   template <int dim>
   class QCollection;
 }
-class ConstraintMatrix;
+template <typename number>
+class AffineConstraints;
 
 
 // TODO: Move documentation of functions to the functions!
@@ -731,8 +732,8 @@ namespace VectorTools
    *
    * For this case (continuous elements on grids with hanging nodes), please
    * use the interpolate_to_different_mesh function with an additional
-   * ConstraintMatrix argument, see below, or make the field conforming
-   * yourself by calling the @p ConstraintsMatrix::distribute function of your
+   * AffineConstraints argument, see below, or make the field conforming
+   * yourself by calling the @p AffineConstraints::distribute function of your
    * hanging node constraints object.
    *
    * @note: This function works with parallel::distributed::Triangulation, but
@@ -768,11 +769,12 @@ namespace VectorTools
             typename VectorType,
             template <int, int> class DoFHandlerType>
   void
-  interpolate_to_different_mesh(const DoFHandlerType<dim, spacedim> &dof1,
-                                const VectorType &                   u1,
-                                const DoFHandlerType<dim, spacedim> &dof2,
-                                const ConstraintMatrix &constraints,
-                                VectorType &            u2);
+  interpolate_to_different_mesh(
+    const DoFHandlerType<dim, spacedim> &                     dof1,
+    const VectorType &                                        u1,
+    const DoFHandlerType<dim, spacedim> &                     dof2,
+    const AffineConstraints<typename VectorType::value_type> &constraints,
+    VectorType &                                              u2);
 
   /**
    * The same function as above, but takes an InterGridMap object directly as
@@ -787,10 +789,10 @@ namespace VectorTools
             template <int, int> class DoFHandlerType>
   void
   interpolate_to_different_mesh(
-    const InterGridMap<DoFHandlerType<dim, spacedim>> &intergridmap,
-    const VectorType &                                 u1,
-    const ConstraintMatrix &                           constraints,
-    VectorType &                                       u2);
+    const InterGridMap<DoFHandlerType<dim, spacedim>> &       intergridmap,
+    const VectorType &                                        u1,
+    const AffineConstraints<typename VectorType::value_type> &constraints,
+    VectorType &                                              u2);
 
   /**
    * Compute the projection of @p function to the finite element space.
@@ -845,10 +847,10 @@ namespace VectorTools
    */
   template <int dim, typename VectorType, int spacedim>
   void
-  project(const Mapping<dim, spacedim> &   mapping,
-          const DoFHandler<dim, spacedim> &dof,
-          const ConstraintMatrix &         constraints,
-          const Quadrature<dim> &          quadrature,
+  project(const Mapping<dim, spacedim> &                            mapping,
+          const DoFHandler<dim, spacedim> &                         dof,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
+          const Quadrature<dim> &                                   quadrature,
           const Function<spacedim, typename VectorType::value_type> &function,
           VectorType &                                               vec,
           const bool                 enforce_zero_boundary     = false,
@@ -863,9 +865,9 @@ namespace VectorTools
    */
   template <int dim, typename VectorType, int spacedim>
   void
-  project(const DoFHandler<dim, spacedim> &dof,
-          const ConstraintMatrix &         constraints,
-          const Quadrature<dim> &          quadrature,
+  project(const DoFHandler<dim, spacedim> &                         dof,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
+          const Quadrature<dim> &                                   quadrature,
           const Function<spacedim, typename VectorType::value_type> &function,
           VectorType &                                               vec,
           const bool                 enforce_zero_boundary     = false,
@@ -880,10 +882,10 @@ namespace VectorTools
    */
   template <int dim, typename VectorType, int spacedim>
   void
-  project(const hp::MappingCollection<dim, spacedim> &mapping,
-          const hp::DoFHandler<dim, spacedim> &       dof,
-          const ConstraintMatrix &                    constraints,
-          const hp::QCollection<dim> &                quadrature,
+  project(const hp::MappingCollection<dim, spacedim> &              mapping,
+          const hp::DoFHandler<dim, spacedim> &                     dof,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
+          const hp::QCollection<dim> &                              quadrature,
           const Function<spacedim, typename VectorType::value_type> &function,
           VectorType &                                               vec,
           const bool                      enforce_zero_boundary = false,
@@ -897,9 +899,9 @@ namespace VectorTools
    */
   template <int dim, typename VectorType, int spacedim>
   void
-  project(const hp::DoFHandler<dim, spacedim> &dof,
-          const ConstraintMatrix &             constraints,
-          const hp::QCollection<dim> &         quadrature,
+  project(const hp::DoFHandler<dim, spacedim> &                     dof,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
+          const hp::QCollection<dim> &                              quadrature,
           const Function<spacedim, typename VectorType::value_type> &function,
           VectorType &                                               vec,
           const bool                      enforce_zero_boundary = false,
@@ -930,14 +932,14 @@ namespace VectorTools
    */
   template <int dim, typename VectorType, int spacedim>
   void
-  project(const Mapping<dim, spacedim> &   mapping,
-          const DoFHandler<dim, spacedim> &dof,
-          const ConstraintMatrix &         constraints,
-          const Quadrature<dim> &          quadrature,
+  project(const Mapping<dim, spacedim> &                            mapping,
+          const DoFHandler<dim, spacedim> &                         dof,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
+          const Quadrature<dim> &                                   quadrature,
           const std::function<typename VectorType::value_type(
             const typename DoFHandler<dim, spacedim>::active_cell_iterator &,
-            const unsigned int)> &         func,
-          VectorType &                     vec_result);
+            const unsigned int)> &                                  func,
+          VectorType &                                              vec_result);
 
   /**
    * The same as above for projection of scalar-valued MatrixFree quadrature
@@ -967,7 +969,7 @@ namespace VectorTools
   void
   project(std::shared_ptr<
             const MatrixFree<dim, typename VectorType::value_type>> data,
-          const ConstraintMatrix &                                  constraints,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
           const unsigned int      n_q_points_1d,
           const std::function<VectorizedArray<typename VectorType::value_type>(
             const unsigned int,
@@ -983,7 +985,7 @@ namespace VectorTools
   void
   project(std::shared_ptr<
             const MatrixFree<dim, typename VectorType::value_type>> data,
-          const ConstraintMatrix &                                  constraints,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
           const std::function<VectorizedArray<typename VectorType::value_type>(
             const unsigned int,
             const unsigned int)> &                                  func,
@@ -1145,7 +1147,7 @@ namespace VectorTools
    *
    * @note When combining adaptively refined meshes with hanging node
    * constraints and boundary conditions like from the current function within
-   * one ConstraintMatrix object, the hanging node constraints should always
+   * one AffineConstraints object, the hanging node constraints should always
    * be set first, and then the boundary conditions since boundary conditions
    * are not set in the second operation on degrees of freedom that are
    * already constrained. This makes sure that the discretization remains
@@ -1201,9 +1203,9 @@ namespace VectorTools
     const Mapping<dim, spacedim> &       mapping,
     const DoFHandlerType<dim, spacedim> &dof,
     const std::map<types::boundary_id, const Function<spacedim, number> *>
-      &                  function_map,
-    ConstraintMatrix &   constraints,
-    const ComponentMask &component_mask = ComponentMask());
+      &                        function_map,
+    AffineConstraints<number> &constraints,
+    const ComponentMask &      component_mask = ComponentMask());
 
   /**
    * Same function as above, but taking only one pair of boundary indicator
@@ -1226,7 +1228,7 @@ namespace VectorTools
     const DoFHandlerType<dim, spacedim> &dof,
     const types::boundary_id             boundary_component,
     const Function<spacedim, number> &   boundary_function,
-    ConstraintMatrix &                   constraints,
+    AffineConstraints<number> &          constraints,
     const ComponentMask &                component_mask = ComponentMask());
 
   /**
@@ -1249,7 +1251,7 @@ namespace VectorTools
     const DoFHandlerType<dim, spacedim> &dof,
     const types::boundary_id             boundary_component,
     const Function<spacedim, number> &   boundary_function,
-    ConstraintMatrix &                   constraints,
+    AffineConstraints<number> &          constraints,
     const ComponentMask &                component_mask = ComponentMask());
 
 
@@ -1269,9 +1271,9 @@ namespace VectorTools
   interpolate_boundary_values(
     const DoFHandlerType<dim, spacedim> &dof,
     const std::map<types::boundary_id, const Function<spacedim, number> *>
-      &                  function_map,
-    ConstraintMatrix &   constraints,
-    const ComponentMask &component_mask = ComponentMask());
+      &                        function_map,
+    AffineConstraints<number> &constraints,
+    const ComponentMask &      component_mask = ComponentMask());
 
 
   /**
@@ -1405,7 +1407,7 @@ namespace VectorTools
    *
    * @note When combining adaptively refined meshes with hanging node
    * constraints and boundary conditions like from the current function within
-   * one ConstraintMatrix object, the hanging node constraints should always
+   * one AffineConstraints object, the hanging node constraints should always
    * be set first, and then the boundary conditions since boundary conditions
    * are not set in the second operation on degrees of freedom that are
    * already constrained. This makes sure that the discretization remains
@@ -1437,7 +1439,7 @@ namespace VectorTools
     const std::map<types::boundary_id, const Function<spacedim, number> *>
       &                        boundary_functions,
     const Quadrature<dim - 1> &q,
-    ConstraintMatrix &         constraints,
+    AffineConstraints<number> &constraints,
     std::vector<unsigned int>  component_mapping = std::vector<unsigned int>());
 
   /**
@@ -1453,7 +1455,7 @@ namespace VectorTools
     const std::map<types::boundary_id, const Function<spacedim, number> *>
       &                        boundary_function,
     const Quadrature<dim - 1> &q,
-    ConstraintMatrix &         constraints,
+    AffineConstraints<number> &constraints,
     std::vector<unsigned int>  component_mapping = std::vector<unsigned int>());
 
 
@@ -1518,7 +1520,7 @@ namespace VectorTools
     const unsigned int           first_vector_component,
     const Function<dim, double> &boundary_function,
     const types::boundary_id     boundary_component,
-    ConstraintMatrix &           constraints,
+    AffineConstraints<double> &  constraints,
     const Mapping<dim> &         mapping = StaticMappingQ1<dim>::mapping);
 
   /**
@@ -1536,7 +1538,7 @@ namespace VectorTools
     const unsigned int                     first_vector_component,
     const Function<dim, double> &          boundary_function,
     const types::boundary_id               boundary_component,
-    ConstraintMatrix &                     constraints,
+    AffineConstraints<double> &            constraints,
     const hp::MappingCollection<dim, dim> &mapping_collection =
       hp::StaticMappingQ1<dim>::mapping_collection);
 
@@ -1642,7 +1644,7 @@ namespace VectorTools
     const unsigned int           first_vector_component,
     const Function<dim, double> &boundary_function,
     const types::boundary_id     boundary_component,
-    ConstraintMatrix &           constraints,
+    AffineConstraints<double> &  constraints,
     const Mapping<dim> &         mapping = StaticMappingQ1<dim>::mapping);
 
 
@@ -1659,7 +1661,7 @@ namespace VectorTools
     const unsigned int                     first_vector_component,
     const Function<dim, double> &          boundary_function,
     const types::boundary_id               boundary_component,
-    ConstraintMatrix &                     constraints,
+    AffineConstraints<double> &            constraints,
     const hp::MappingCollection<dim, dim> &mapping_collection =
       hp::StaticMappingQ1<dim>::mapping_collection);
 
@@ -1675,7 +1677,7 @@ namespace VectorTools
    * elements. Thus it throws an exception, if it is called with other finite
    * elements.
    *
-   * If the ConstraintMatrix @p constraints contained values or other
+   * If the AffineConstraints object @p constraints contained values or other
    * constraints before, the new ones are added or the old ones overwritten,
    * if a node of the boundary part to be used was already in the list of
    * constraints. This is handled by using inhomogeneous constraints. Please
@@ -1717,7 +1719,7 @@ namespace VectorTools
     const unsigned int           first_vector_component,
     const Function<dim, double> &boundary_function,
     const types::boundary_id     boundary_component,
-    ConstraintMatrix &           constraints,
+    AffineConstraints<double> &  constraints,
     const Mapping<dim> &         mapping = StaticMappingQ1<dim>::mapping);
 
   /**
@@ -1735,7 +1737,7 @@ namespace VectorTools
     const unsigned int                     first_vector_component,
     const Function<dim, double> &          boundary_function,
     const types::boundary_id               boundary_component,
-    ConstraintMatrix &                     constraints,
+    AffineConstraints<double> &            constraints,
     const hp::MappingCollection<dim, dim> &mapping_collection =
       hp::StaticMappingQ1<dim>::mapping_collection);
 
@@ -1973,7 +1975,7 @@ namespace VectorTools
     const unsigned int                    first_vector_component,
     const std::set<types::boundary_id> &  boundary_ids,
     typename FunctionMap<spacedim>::type &function_map,
-    ConstraintMatrix &                    constraints,
+    AffineConstraints<double> &           constraints,
     const Mapping<dim, spacedim> &mapping = StaticMappingQ1<dim>::mapping);
 
   /**
@@ -1994,7 +1996,7 @@ namespace VectorTools
     const DoFHandlerType<dim, spacedim> &dof_handler,
     const unsigned int                   first_vector_component,
     const std::set<types::boundary_id> & boundary_ids,
-    ConstraintMatrix &                   constraints,
+    AffineConstraints<double> &          constraints,
     const Mapping<dim, spacedim> &mapping = StaticMappingQ1<dim>::mapping);
 
   /**
@@ -2020,7 +2022,7 @@ namespace VectorTools
     const unsigned int                    first_vector_component,
     const std::set<types::boundary_id> &  boundary_ids,
     typename FunctionMap<spacedim>::type &function_map,
-    ConstraintMatrix &                    constraints,
+    AffineConstraints<double> &           constraints,
     const Mapping<dim, spacedim> &mapping = StaticMappingQ1<dim>::mapping);
 
   /**
@@ -2037,7 +2039,7 @@ namespace VectorTools
     const DoFHandlerType<dim, spacedim> &dof_handler,
     const unsigned int                   first_vector_component,
     const std::set<types::boundary_id> & boundary_ids,
-    ConstraintMatrix &                   constraints,
+    AffineConstraints<double> &          constraints,
     const Mapping<dim, spacedim> &mapping = StaticMappingQ1<dim>::mapping);
 
 
@@ -2061,7 +2063,8 @@ namespace VectorTools
     const Quadrature<dim> &                                    q,
     const Function<spacedim, typename VectorType::value_type> &rhs,
     VectorType &                                               rhs_vector,
-    const ConstraintMatrix &constraints = ConstraintMatrix());
+    const AffineConstraints<typename VectorType::value_type> & constraints =
+      AffineConstraints<typename VectorType::value_type>());
 
   /**
    * Call the create_right_hand_side() function, see above, with
@@ -2074,7 +2077,8 @@ namespace VectorTools
     const Quadrature<dim> &                                    q,
     const Function<spacedim, typename VectorType::value_type> &rhs,
     VectorType &                                               rhs_vector,
-    const ConstraintMatrix &constraints = ConstraintMatrix());
+    const AffineConstraints<typename VectorType::value_type> & constraints =
+      AffineConstraints<typename VectorType::value_type>());
 
   /**
    * Like the previous set of functions, but for hp objects.
@@ -2087,7 +2091,8 @@ namespace VectorTools
     const hp::QCollection<dim> &                               q,
     const Function<spacedim, typename VectorType::value_type> &rhs,
     VectorType &                                               rhs_vector,
-    const ConstraintMatrix &constraints = ConstraintMatrix());
+    const AffineConstraints<typename VectorType::value_type> & constraints =
+      AffineConstraints<typename VectorType::value_type>());
 
   /**
    * Like the previous set of functions, but for hp objects.
@@ -2099,7 +2104,8 @@ namespace VectorTools
     const hp::QCollection<dim> &                               q,
     const Function<spacedim, typename VectorType::value_type> &rhs,
     VectorType &                                               rhs_vector,
-    const ConstraintMatrix &constraints = ConstraintMatrix());
+    const AffineConstraints<typename VectorType::value_type> & constraints =
+      AffineConstraints<typename VectorType::value_type>());
 
   /**
    * Create a right hand side vector for a point source at point @p p. In
index 67b1d22127698d4edb8f197226bb1a4a860fe6ac..3260c64c434d30c2df9ce58751eba9537977b65a 100644 (file)
@@ -55,8 +55,8 @@
 #include <deal.II/hp/mapping_collection.h>
 #include <deal.II/hp/q_collection.h>
 
+#include <deal.II/lac/affine_constraints.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/constraint_matrix.h>
 #include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/filtered_matrix.h>
 #include <deal.II/lac/la_parallel_block_vector.h>
@@ -747,7 +747,7 @@ namespace VectorTools
     InterGridMap<DoFHandlerType<dim, spacedim>> intergridmap;
     intergridmap.make_mapping(dof1, dof2);
 
-    ConstraintMatrix dummy;
+    AffineConstraints<typename VectorType::value_type> dummy;
     dummy.close();
 
     interpolate_to_different_mesh(intergridmap, u1, dummy, u2);
@@ -760,11 +760,12 @@ namespace VectorTools
             typename VectorType,
             template <int, int> class DoFHandlerType>
   void
-  interpolate_to_different_mesh(const DoFHandlerType<dim, spacedim> &dof1,
-                                const VectorType &                   u1,
-                                const DoFHandlerType<dim, spacedim> &dof2,
-                                const ConstraintMatrix &constraints,
-                                VectorType &            u2)
+  interpolate_to_different_mesh(
+    const DoFHandlerType<dim, spacedim> &                     dof1,
+    const VectorType &                                        u1,
+    const DoFHandlerType<dim, spacedim> &                     dof2,
+    const AffineConstraints<typename VectorType::value_type> &constraints,
+    VectorType &                                              u2)
   {
     Assert(GridTools::have_same_coarse_mesh(dof1, dof2),
            ExcMessage("The two DoF handlers must represent triangulations that "
@@ -803,10 +804,10 @@ namespace VectorTools
             template <int, int> class DoFHandlerType>
   void
   interpolate_to_different_mesh(
-    const InterGridMap<DoFHandlerType<dim, spacedim>> &intergridmap,
-    const VectorType &                                 u1,
-    const ConstraintMatrix &                           constraints,
-    VectorType &                                       u2)
+    const InterGridMap<DoFHandlerType<dim, spacedim>> &       intergridmap,
+    const VectorType &                                        u1,
+    const AffineConstraints<typename VectorType::value_type> &constraints,
+    VectorType &                                              u2)
   {
     const DoFHandlerType<dim, spacedim> &dof1 = intergridmap.get_source_grid();
     const DoFHandlerType<dim, spacedim> &dof2 =
@@ -938,7 +939,7 @@ namespace VectorTools
     template <typename number>
     bool
     constraints_and_b_v_are_compatible(
-      const ConstraintMatrix &                   constraints,
+      const AffineConstraints<number> &          constraints,
       std::map<types::global_dof_index, number> &boundary_values)
     {
       for (typename std::map<types::global_dof_index, number>::iterator it =
@@ -1000,7 +1001,7 @@ namespace VectorTools
     do_project(
       const M_or_MC<dim, spacedim> &                             mapping,
       const DoFHandlerType<dim, spacedim> &                      dof,
-      const ConstraintMatrix &                                   constraints,
+      const AffineConstraints<typename VectorType::value_type> & constraints,
       const Q_or_QC<dim> &                                       quadrature,
       const Function<spacedim, typename VectorType::value_type> &function,
       VectorType &                                               vec_result,
@@ -1099,7 +1100,7 @@ namespace VectorTools
     project_matrix_free(
       const Mapping<dim, spacedim> &   mapping,
       const DoFHandler<dim, spacedim> &dof,
-      const ConstraintMatrix &         constraints,
+      const AffineConstraints<Number> &constraints,
       const Quadrature<dim> &          quadrature,
       const Function<
         spacedim,
@@ -1206,7 +1207,7 @@ namespace VectorTools
     project_matrix_free_degree(
       const Mapping<dim, spacedim> &   mapping,
       const DoFHandler<dim, spacedim> &dof,
-      const ConstraintMatrix &         constraints,
+      const AffineConstraints<Number> &constraints,
       const Quadrature<dim> &          quadrature,
       const Function<
         spacedim,
@@ -1277,7 +1278,7 @@ namespace VectorTools
     project_matrix_free_component(
       const Mapping<dim, spacedim> &   mapping,
       const DoFHandler<dim, spacedim> &dof,
-      const ConstraintMatrix &         constraints,
+      const AffineConstraints<Number> &constraints,
       const Quadrature<dim> &          quadrature,
       const Function<
         spacedim,
@@ -1355,7 +1356,7 @@ namespace VectorTools
     project_matrix_free_copy_vector(
       const Mapping<dim, spacedim> &                             mapping,
       const DoFHandler<dim, spacedim> &                          dof,
-      const ConstraintMatrix &                                   constraints,
+      const AffineConstraints<typename VectorType::value_type> & constraints,
       const Quadrature<dim> &                                    quadrature,
       const Function<spacedim, typename VectorType::value_type> &function,
       VectorType &                                               vec_result,
@@ -1395,15 +1396,16 @@ namespace VectorTools
      */
     template <typename VectorType, int dim>
     void
-    project(const Mapping<dim> &                                  mapping,
-            const DoFHandler<dim> &                               dof,
-            const ConstraintMatrix &                              constraints,
-            const Quadrature<dim> &                               quadrature,
-            const Function<dim, typename VectorType::value_type> &function,
-            VectorType &                                          vec_result,
-            const bool                 enforce_zero_boundary,
-            const Quadrature<dim - 1> &q_boundary,
-            const bool                 project_to_boundary_first)
+    project(
+      const Mapping<dim> &                                      mapping,
+      const DoFHandler<dim> &                                   dof,
+      const AffineConstraints<typename VectorType::value_type> &constraints,
+      const Quadrature<dim> &                                   quadrature,
+      const Function<dim, typename VectorType::value_type> &    function,
+      VectorType &                                              vec_result,
+      const bool                 enforce_zero_boundary,
+      const Quadrature<dim - 1> &q_boundary,
+      const bool                 project_to_boundary_first)
     {
       // If we can, use the matrix-free implementation
       bool use_matrix_free =
@@ -1450,14 +1452,14 @@ namespace VectorTools
     template <int dim, typename VectorType, int spacedim, int fe_degree>
     void
     project_parallel(
-      const Mapping<dim, spacedim> &   mapping,
-      const DoFHandler<dim, spacedim> &dof,
-      const ConstraintMatrix &         constraints,
-      const Quadrature<dim> &          quadrature,
+      const Mapping<dim, spacedim> &                            mapping,
+      const DoFHandler<dim, spacedim> &                         dof,
+      const AffineConstraints<typename VectorType::value_type> &constraints,
+      const Quadrature<dim> &                                   quadrature,
       const std::function<typename VectorType::value_type(
         const typename DoFHandler<dim, spacedim>::active_cell_iterator &,
-        const unsigned int)> &         func,
-      VectorType &                     vec_result)
+        const unsigned int)> &                                  func,
+      VectorType &                                              vec_result)
     {
       typedef typename VectorType::value_type Number;
       Assert(dof.get_fe(0).n_components() == 1,
@@ -1567,13 +1569,13 @@ namespace VectorTools
     void
     project_parallel(
       std::shared_ptr<const MatrixFree<dim, typename VectorType::value_type>>
-                              matrix_free,
-      const ConstraintMatrix &constraints,
+                                                                matrix_free,
+      const AffineConstraints<typename VectorType::value_type> &constraints,
       const std::function<VectorizedArray<typename VectorType::value_type>(
         const unsigned int,
-        const unsigned int)> &func,
-      VectorType &            vec_result,
-      const unsigned int      fe_component)
+        const unsigned int)> &                                  func,
+      VectorType &                                              vec_result,
+      const unsigned int                                        fe_component)
     {
       const DoFHandler<dim, spacedim> &dof =
         matrix_free->get_dof_handler(fe_component);
@@ -1655,14 +1657,14 @@ namespace VectorTools
 
   template <int dim, typename VectorType, int spacedim>
   void
-  project(const Mapping<dim, spacedim> &   mapping,
-          const DoFHandler<dim, spacedim> &dof,
-          const ConstraintMatrix &         constraints,
-          const Quadrature<dim> &          quadrature,
+  project(const Mapping<dim, spacedim> &                            mapping,
+          const DoFHandler<dim, spacedim> &                         dof,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
+          const Quadrature<dim> &                                   quadrature,
           const std::function<typename VectorType::value_type(
             const typename DoFHandler<dim, spacedim>::active_cell_iterator &,
-            const unsigned int)> &         func,
-          VectorType &                     vec_result)
+            const unsigned int)> &                                  func,
+          VectorType &                                              vec_result)
   {
     switch (dof.get_fe().degree)
       {
@@ -1690,7 +1692,7 @@ namespace VectorTools
   void
   project(std::shared_ptr<
             const MatrixFree<dim, typename VectorType::value_type>> matrix_free,
-          const ConstraintMatrix &                                  constraints,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
           const unsigned int      n_q_points_1d,
           const std::function<VectorizedArray<typename VectorType::value_type>(
             const unsigned int,
@@ -1731,7 +1733,7 @@ namespace VectorTools
   void
   project(std::shared_ptr<
             const MatrixFree<dim, typename VectorType::value_type>> matrix_free,
-          const ConstraintMatrix &                                  constraints,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
           const std::function<VectorizedArray<typename VectorType::value_type>(
             const unsigned int,
             const unsigned int)> &                                  func,
@@ -1750,10 +1752,10 @@ namespace VectorTools
 
   template <int dim, typename VectorType, int spacedim>
   void
-  project(const Mapping<dim, spacedim> &   mapping,
-          const DoFHandler<dim, spacedim> &dof,
-          const ConstraintMatrix &         constraints,
-          const Quadrature<dim> &          quadrature,
+  project(const Mapping<dim, spacedim> &                            mapping,
+          const DoFHandler<dim, spacedim> &                         dof,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
+          const Quadrature<dim> &                                   quadrature,
           const Function<spacedim, typename VectorType::value_type> &function,
           VectorType &                                               vec_result,
           const bool                 enforce_zero_boundary,
@@ -1803,9 +1805,9 @@ namespace VectorTools
 
   template <int dim, typename VectorType, int spacedim>
   void
-  project(const DoFHandler<dim, spacedim> &dof,
-          const ConstraintMatrix &         constraints,
-          const Quadrature<dim> &          quadrature,
+  project(const DoFHandler<dim, spacedim> &                         dof,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
+          const Quadrature<dim> &                                   quadrature,
           const Function<spacedim, typename VectorType::value_type> &function,
           VectorType &                                               vec,
           const bool                 enforce_zero_boundary,
@@ -1833,10 +1835,10 @@ namespace VectorTools
 
   template <int dim, typename VectorType, int spacedim>
   void
-  project(const hp::MappingCollection<dim, spacedim> &mapping,
-          const hp::DoFHandler<dim, spacedim> &       dof,
-          const ConstraintMatrix &                    constraints,
-          const hp::QCollection<dim> &                quadrature,
+  project(const hp::MappingCollection<dim, spacedim> &              mapping,
+          const hp::DoFHandler<dim, spacedim> &                     dof,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
+          const hp::QCollection<dim> &                              quadrature,
           const Function<spacedim, typename VectorType::value_type> &function,
           VectorType &                                               vec_result,
           const bool                      enforce_zero_boundary,
@@ -1861,9 +1863,9 @@ namespace VectorTools
 
   template <int dim, typename VectorType, int spacedim>
   void
-  project(const hp::DoFHandler<dim, spacedim> &dof,
-          const ConstraintMatrix &             constraints,
-          const hp::QCollection<dim> &         quadrature,
+  project(const hp::DoFHandler<dim, spacedim> &                     dof,
+          const AffineConstraints<typename VectorType::value_type> &constraints,
+          const hp::QCollection<dim> &                              quadrature,
           const Function<spacedim, typename VectorType::value_type> &function,
           VectorType &                                               vec,
           const bool                      enforce_zero_boundary,
@@ -1891,7 +1893,7 @@ namespace VectorTools
     const Quadrature<dim> &                                    quadrature,
     const Function<spacedim, typename VectorType::value_type> &rhs_function,
     VectorType &                                               rhs_vector,
-    const ConstraintMatrix &                                   constraints)
+    const AffineConstraints<typename VectorType::value_type> & constraints)
   {
     typedef typename VectorType::value_type Number;
 
@@ -2007,7 +2009,7 @@ namespace VectorTools
     const Quadrature<dim> &                                    quadrature,
     const Function<spacedim, typename VectorType::value_type> &rhs_function,
     VectorType &                                               rhs_vector,
-    const ConstraintMatrix &                                   constraints)
+    const AffineConstraints<typename VectorType::value_type> & constraints)
   {
     create_right_hand_side(StaticMappingQ1<dim, spacedim>::mapping,
                            dof_handler,
@@ -2027,7 +2029,7 @@ namespace VectorTools
     const hp::QCollection<dim> &                               quadrature,
     const Function<spacedim, typename VectorType::value_type> &rhs_function,
     VectorType &                                               rhs_vector,
-    const ConstraintMatrix &                                   constraints)
+    const AffineConstraints<typename VectorType::value_type> & constraints)
   {
     typedef typename VectorType::value_type Number;
 
@@ -2160,7 +2162,7 @@ namespace VectorTools
     const hp::QCollection<dim> &                               quadrature,
     const Function<spacedim, typename VectorType::value_type> &rhs_function,
     VectorType &                                               rhs_vector,
-    const ConstraintMatrix &                                   constraints)
+    const AffineConstraints<typename VectorType::value_type> & constraints)
   {
     create_right_hand_side(
       hp::StaticMappingQ1<dim, spacedim>::mapping_collection,
@@ -3130,7 +3132,8 @@ namespace VectorTools
 
 
 
-  // ----------- interpolate_boundary_values for ConstraintMatrix --------------
+  // ----------- interpolate_boundary_values for AffineConstraints
+  // --------------
 
 
 
@@ -3143,9 +3146,9 @@ namespace VectorTools
     const Mapping<dim, spacedim> &       mapping,
     const DoFHandlerType<dim, spacedim> &dof,
     const std::map<types::boundary_id, const Function<spacedim, number> *>
-      &                  function_map,
-    ConstraintMatrix &   constraints,
-    const ComponentMask &component_mask_)
+      &                        function_map,
+    AffineConstraints<number> &constraints,
+    const ComponentMask &      component_mask_)
   {
     std::map<types::global_dof_index, number> boundary_values;
     interpolate_boundary_values(
@@ -3176,7 +3179,7 @@ namespace VectorTools
     const DoFHandlerType<dim, spacedim> &dof,
     const types::boundary_id             boundary_component,
     const Function<spacedim, number> &   boundary_function,
-    ConstraintMatrix &                   constraints,
+    AffineConstraints<number> &          constraints,
     const ComponentMask &                component_mask)
   {
     std::map<types::boundary_id, const Function<spacedim, number> *>
@@ -3197,7 +3200,7 @@ namespace VectorTools
     const DoFHandlerType<dim, spacedim> &dof,
     const types::boundary_id             boundary_component,
     const Function<spacedim, number> &   boundary_function,
-    ConstraintMatrix &                   constraints,
+    AffineConstraints<number> &          constraints,
     const ComponentMask &                component_mask)
   {
     interpolate_boundary_values(StaticMappingQ1<dim, spacedim>::mapping,
@@ -3218,9 +3221,9 @@ namespace VectorTools
   interpolate_boundary_values(
     const DoFHandlerType<dim, spacedim> &dof,
     const std::map<types::boundary_id, const Function<spacedim, number> *>
-      &                  function_map,
-    ConstraintMatrix &   constraints,
-    const ComponentMask &component_mask)
+      &                        function_map,
+    AffineConstraints<number> &constraints,
+    const ComponentMask &      component_mask)
   {
     interpolate_boundary_values(StaticMappingQ1<dim, spacedim>::mapping,
                                 dof,
@@ -3479,9 +3482,8 @@ namespace VectorTools
 
 
       // make mass matrix and right hand side
-      SparseMatrix<typename numbers::NumberTraits<number>::real_type>
-                     mass_matrix(sparsity);
-      Vector<number> rhs(sparsity.n_rows());
+      SparseMatrix<number> mass_matrix(sparsity);
+      Vector<number>       rhs(sparsity.n_rows());
 
 
       MatrixCreator::create_boundary_mass_matrix(
@@ -3492,9 +3494,7 @@ namespace VectorTools
         boundary_functions,
         rhs,
         dof_to_boundary_mapping,
-        (const Function<spacedim,
-                        typename numbers::NumberTraits<number>::real_type>
-           *)nullptr,
+        (const Function<spacedim, number> *)nullptr,
         component_mapping);
 
       // For certain weird elements,
@@ -3509,11 +3509,9 @@ namespace VectorTools
 
       // TODO: Maybe we should figure out if the element really needs this
 
-      FilteredMatrix<Vector<typename numbers::NumberTraits<number>::real_type>>
-        filtered_mass_matrix(mass_matrix, true);
-      FilteredMatrix<Vector<typename numbers::NumberTraits<number>::real_type>>
-                        filtered_precondition;
-      std::vector<bool> excluded_dofs(mass_matrix.m(), false);
+      FilteredMatrix<Vector<number>> filtered_mass_matrix(mass_matrix, true);
+      FilteredMatrix<Vector<number>> filtered_precondition;
+      std::vector<bool>              excluded_dofs(mass_matrix.m(), false);
 
       // we assemble mass matrix with unit weight,
       // thus it will be real-valued irrespectively of the underlying algebra
@@ -3643,7 +3641,7 @@ namespace VectorTools
   }
 
 
-  // ---- implementation for project_boundary_values with ConstraintMatrix ----
+  // ---- implementation for project_boundary_values with AffineConstraints ----
 
 
 
@@ -3655,7 +3653,7 @@ namespace VectorTools
     const std::map<types::boundary_id, const Function<spacedim, number> *>
       &                        boundary_functions,
     const Quadrature<dim - 1> &q,
-    ConstraintMatrix &         constraints,
+    AffineConstraints<number> &constraints,
     std::vector<unsigned int>  component_mapping)
   {
     std::map<types::global_dof_index, number> boundary_values;
@@ -3683,7 +3681,7 @@ namespace VectorTools
     const std::map<types::boundary_id, const Function<spacedim, number> *>
       &                        boundary_functions,
     const Quadrature<dim - 1> &q,
-    ConstraintMatrix &         constraints,
+    AffineConstraints<number> &constraints,
     std::vector<unsigned int>  component_mapping)
   {
     project_boundary_values(StaticMappingQ1<dim, spacedim>::mapping,
@@ -3768,69 +3766,42 @@ namespace VectorTools
     void
     add_constraint(const VectorDoFTuple<dim> &dof_indices,
                    const Tensor<1, dim> &     constraining_vector,
-                   ConstraintMatrix &         constraints,
+                   AffineConstraints<double> &constraints,
                    const double               inhomogeneity = 0)
     {
-      // choose the DoF that has the
-      // largest component in the
-      // constraining_vector as the
-      // one to be constrained as
-      // this makes the process
-      // stable in cases where the
-      // constraining_vector has the
-      // form n=(1,0) or n=(0,1)
+      // choose the DoF that has the largest component in the
+      // constraining_vector as the one to be constrained as this makes the
+      // process stable in cases where the constraining_vector has the form
+      // n=(1,0) or n=(0,1)
       //
-      // we get constraints of the form
-      //   x0 = a_1*x1 + a2*x2 + ...
-      // if one of the weights is
-      // essentially zero then skip
-      // this part. the ConstraintMatrix
-      // can also deal with cases like
-      //   x0 = 0
-      // if necessary
+      // we get constraints of the form x0 = a_1*x1 + a2*x2 + ... if one of
+      // the weights is essentially zero then skip this part. the
+      // AffineConstraints can also deal with cases like x0 = 0 if
+      // necessary
       //
-      // there is a problem if we have a
-      // normal vector of the form
-      // (a,a,small) or (a,a,a). Depending on
-      // round-off we may choose the first or
-      // second component (or third, in the
-      // latter case) as the largest one, and
-      // depending on our choice one or
-      // another degree of freedom will be
-      // constrained. On a single processor
-      // this is not much of a problem, but
-      // it's a nightmare when we run in
-      // parallel and two processors disagree
-      // on which DoF should be
-      // constrained. This led to an
-      // incredibly difficult to find bug in
-      // step-32 when running in parallel
-      // with 9 or more processors.
+      // there is a problem if we have a normal vector of the form
+      // (a,a,small) or (a,a,a). Depending on round-off we may choose the
+      // first or second component (or third, in the latter case) as the
+      // largest one, and depending on our choice one or another degree of
+      // freedom will be constrained. On a single processor this is not
+      // much of a problem, but it's a nightmare when we run in parallel
+      // and two processors disagree on which DoF should be constrained.
+      // This led to an incredibly difficult to find bug in step-32 when
+      // running in parallel with 9 or more processors.
       //
-      // in practice, such normal vectors of
-      // the form (a,a,small) or (a,a,a)
-      // happen not infrequently since they
-      // lie on the diagonals where vertices
-      // frequently happen to land upon mesh
-      // refinement if one starts from a
-      // symmetric and regular body. we work
-      // around this problem in the following
-      // way: if we have a normal vector of
-      // the form (a,b) (similarly algorithm
-      // in 3d), we choose 'a' as the largest
-      // coefficient not if a>b but if
-      // a>b+1e-10. this shifts the problem
-      // away from the frequently visited
-      // diagonal to a line that is off the
-      // diagonal. there will of course be
-      // problems where the exact values of a
-      // and b differ by exactly 1e-10 and we
-      // get into the same instability, but
-      // from a practical viewpoint such
-      // problems should be much rarer. in
-      // particular, meshes have to be very
-      // fine for a vertex to land on
-      // this line if the original body had a
+      // in practice, such normal vectors of the form (a,a,small) or
+      // (a,a,a) happen not infrequently since they lie on the diagonals
+      // where vertices frequently happen to land upon mesh refinement if
+      // one starts from a symmetric and regular body. we work around this
+      // problem in the following way: if we have a normal vector of the
+      // form (a,b) (similarly algorithm in 3d), we choose 'a' as the
+      // largest coefficient not if a>b but if a>b+1e-10. this shifts the
+      // problem away from the frequently visited diagonal to a line that
+      // is off the diagonal. there will of course be problems where the
+      // exact values of a and b differ by exactly 1e-10 and we get into
+      // the same instability, but from a practical viewpoint such problems
+      // should be much rarer. in particular, meshes have to be very fine
+      // for a vertex to land on this line if the original body had a
       // vertex on the diagonal as well
       switch (dim)
         {
@@ -4008,7 +3979,7 @@ namespace VectorTools
     add_tangentiality_constraints(
       const VectorDoFTuple<dim> &dof_indices,
       const Tensor<1, dim> &     tangent_vector,
-      ConstraintMatrix &         constraints,
+      AffineConstraints<double> &constraints,
       const Vector<double> &     b_values = Vector<double>(dim))
     {
       // choose the DoF that has the
@@ -4808,12 +4779,12 @@ namespace VectorTools
   void
 
   project_boundary_values_curl_conforming(
-    const DoFHandler<dim> &  dof_handler,
-    const unsigned int       first_vector_component,
-    const Function<dim> &    boundary_function,
-    const types::boundary_id boundary_component,
-    ConstraintMatrix &       constraints,
-    const Mapping<dim> &     mapping)
+    const DoFHandler<dim> &    dof_handler,
+    const unsigned int         first_vector_component,
+    const Function<dim> &      boundary_function,
+    const types::boundary_id   boundary_component,
+    AffineConstraints<double> &constraints,
+    const Mapping<dim> &       mapping)
   {
     // Projection-based interpolation is performed in two (in 2D) respectively
     // three (in 3D) steps. First the tangential component of the function is
@@ -5061,7 +5032,7 @@ namespace VectorTools
     const unsigned int                first_vector_component,
     const Function<dim> &             boundary_function,
     const types::boundary_id          boundary_component,
-    ConstraintMatrix &                constraints,
+    AffineConstraints<double> &       constraints,
     const hp::MappingCollection<dim> &mapping_collection)
   {
     const hp::FECollection<dim> &fe_collection(dof_handler.get_fe_collection());
@@ -5986,7 +5957,7 @@ namespace VectorTools
       const unsigned int                     first_vector_component,
       const Function<dim> &                  boundary_function,
       const types::boundary_id               boundary_component,
-      ConstraintMatrix &                     constraints,
+      AffineConstraints<double> &            constraints,
       const hp::MappingCollection<dim, dim> &mapping_collection)
     {
       // L2-projection based interpolation formed in one (in 2D) or two (in 3D)
@@ -6295,12 +6266,12 @@ namespace VectorTools
   template <int dim>
   void
   project_boundary_values_curl_conforming_l2(
-    const DoFHandler<dim> &  dof_handler,
-    const unsigned int       first_vector_component,
-    const Function<dim> &    boundary_function,
-    const types::boundary_id boundary_component,
-    ConstraintMatrix &       constraints,
-    const Mapping<dim> &     mapping)
+    const DoFHandler<dim> &    dof_handler,
+    const unsigned int         first_vector_component,
+    const Function<dim> &      boundary_function,
+    const types::boundary_id   boundary_component,
+    AffineConstraints<double> &constraints,
+    const Mapping<dim> &       mapping)
   {
     // non-hp version - calls the internal
     // compute_project_boundary_values_curl_conforming_l2() function
@@ -6323,7 +6294,7 @@ namespace VectorTools
     const unsigned int                     first_vector_component,
     const Function<dim> &                  boundary_function,
     const types::boundary_id               boundary_component,
-    ConstraintMatrix &                     constraints,
+    AffineConstraints<double> &            constraints,
     const hp::MappingCollection<dim, dim> &mapping_collection)
   {
     // hp version - calls the internal
@@ -6352,7 +6323,7 @@ namespace VectorTools
       const unsigned int                          first_vector_component,
       const Function<2> &                         boundary_function,
       const std::vector<DerivativeForm<1, 2, 2>> &jacobians,
-      ConstraintMatrix &                          constraints)
+      AffineConstraints<double> &                 constraints)
     {
       // Compute the integral over the product of the normal components of
       // the boundary function times the normal components of the shape
@@ -6403,7 +6374,7 @@ namespace VectorTools
       cell->face(face)->get_dof_indices(face_dof_indices,
                                         cell->active_fe_index());
 
-      // Copy the computed values in the ConstraintMatrix only, if the degree
+      // Copy the computed values in the AffineConstraints only, if the degree
       // of freedom is not already constrained.
       for (unsigned int i = 0; i < fe.dofs_per_face; ++i)
         if (!(constraints.is_constrained(face_dof_indices[i])))
@@ -6425,7 +6396,7 @@ namespace VectorTools
       const unsigned int,
       const Function<dim> &,
       const std::vector<DerivativeForm<1, dim, dim>> &,
-      ConstraintMatrix &)
+      AffineConstraints<double> &)
     {
       Assert(false, ExcNotImplemented());
     }
@@ -6532,12 +6503,12 @@ namespace VectorTools
   template <int dim>
   void
   project_boundary_values_div_conforming(
-    const DoFHandler<dim> &  dof_handler,
-    const unsigned int       first_vector_component,
-    const Function<dim> &    boundary_function,
-    const types::boundary_id boundary_component,
-    ConstraintMatrix &       constraints,
-    const Mapping<dim> &     mapping)
+    const DoFHandler<dim> &    dof_handler,
+    const unsigned int         first_vector_component,
+    const Function<dim> &      boundary_function,
+    const types::boundary_id   boundary_component,
+    AffineConstraints<double> &constraints,
+    const Mapping<dim> &       mapping)
   {
     const unsigned int spacedim = dim;
     // Interpolate the normal components
@@ -6636,23 +6607,13 @@ namespace VectorTools
 
         case 3:
           {
-            // In three dimensions the
-            // edges between two faces
-            // are treated twice.
-            // Therefore we store the
-            // computed values in a
-            // vector and copy them over
-            // in the ConstraintMatrix
-            // after all values have been
-            // computed.
-            // If we have two values for
-            // one edge, we choose the one,
-            // which was computed with the
-            // higher order element.
-            // If both elements are of the
-            // same order, we just keep the
-            // first value and do not
-            // compute a second one.
+            // In three dimensions the edges between two faces are treated
+            // twice. Therefore we store the computed values in a vector
+            // and copy them over in the AffineConstraints after all values
+            // have been computed. If we have two values for one edge, we
+            // choose the one, which was computed with the higher order
+            // element. If both elements are of the same order, we just
+            // keep the first value and do not compute a second one.
             const unsigned int &                 n_dofs = dof_handler.n_dofs();
             std::vector<double>                  dof_values(n_dofs);
             std::vector<types::global_dof_index> projected_dofs(n_dofs);
@@ -6670,12 +6631,9 @@ namespace VectorTools
                      ++face)
                   if (cell->face(face)->boundary_id() == boundary_component)
                     {
-                      // This is only
-                      // implemented, if the
-                      // FE is a Raviart-Thomas
-                      // element. If the FE is
-                      // a FESystem we cannot
-                      // check this.
+                      // This is only implemented, if the FE is a
+                      // Raviart-Thomas element. If the FE is a FESystem we
+                      // cannot check this.
                       if (dynamic_cast<const FESystem<dim> *>(
                             &cell->get_fe()) == nullptr)
                         {
@@ -6733,7 +6691,7 @@ namespace VectorTools
     const unsigned int                     first_vector_component,
     const Function<dim> &                  boundary_function,
     const types::boundary_id               boundary_component,
-    ConstraintMatrix &                     constraints,
+    AffineConstraints<double> &            constraints,
     const hp::MappingCollection<dim, dim> &mapping_collection)
   {
     const unsigned int           spacedim = dim;
@@ -6900,7 +6858,7 @@ namespace VectorTools
     const DoFHandlerType<dim, spacedim> &dof_handler,
     const unsigned int                   first_vector_component,
     const std::set<types::boundary_id> & boundary_ids,
-    ConstraintMatrix &                   constraints,
+    AffineConstraints<double> &          constraints,
     const Mapping<dim, spacedim> &       mapping)
   {
     ZeroFunction<dim>                            zero_function(dim);
@@ -6923,7 +6881,7 @@ namespace VectorTools
     const unsigned int                    first_vector_component,
     const std::set<types::boundary_id> &  boundary_ids,
     typename FunctionMap<spacedim>::type &function_map,
-    ConstraintMatrix &                    constraints,
+    AffineConstraints<double> &           constraints,
     const Mapping<dim, spacedim> &        mapping)
   {
     Assert(dim > 1,
@@ -7506,7 +7464,7 @@ namespace VectorTools
     const DoFHandlerType<dim, spacedim> &dof_handler,
     const unsigned int                   first_vector_component,
     const std::set<types::boundary_id> & boundary_ids,
-    ConstraintMatrix &                   constraints,
+    AffineConstraints<double> &          constraints,
     const Mapping<dim, spacedim> &       mapping)
   {
     ZeroFunction<dim>                            zero_function(dim);
@@ -7529,10 +7487,11 @@ namespace VectorTools
     const unsigned int                    first_vector_component,
     const std::set<types::boundary_id> &  boundary_ids,
     typename FunctionMap<spacedim>::type &function_map,
-    ConstraintMatrix &                    constraints,
+    AffineConstraints<double> &           constraints,
     const Mapping<dim, spacedim> &        mapping)
   {
-    ConstraintMatrix no_normal_flux_constraints(constraints.get_local_lines());
+    AffineConstraints<double> no_normal_flux_constraints(
+      constraints.get_local_lines());
     compute_nonzero_normal_flux_constraints(dof_handler,
                                             first_vector_component,
                                             boundary_ids,
index d93bce9546e1cb56d191962875bf37365b750215..0ede9e500fbd6e6ad6982ffbd6bbdf329833e50a 100644 (file)
@@ -93,7 +93,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS;
         const DH<deal_II_dimension, deal_II_space_dimension> &,
         const std::map<types::boundary_id,
                        const Function<deal_II_space_dimension, double> *> &,
-        ConstraintMatrix &,
+        AffineConstraints<double> &,
         const ComponentMask &);
 
       template void
@@ -102,7 +102,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS;
         const DH<deal_II_dimension, deal_II_space_dimension> &,
         const types::boundary_id,
         const Function<deal_II_space_dimension> &,
-        ConstraintMatrix &,
+        AffineConstraints<double> &,
         const ComponentMask &);
 
       template void
@@ -110,7 +110,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS;
         const DH<deal_II_dimension, deal_II_space_dimension> &,
         const types::boundary_id,
         const Function<deal_II_space_dimension> &,
-        ConstraintMatrix &,
+        AffineConstraints<double> &,
         const ComponentMask &);
 
       template void
@@ -118,7 +118,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS;
         const DH<deal_II_dimension, deal_II_space_dimension> &,
         const std::map<types::boundary_id,
                        const Function<deal_II_space_dimension, double> *> &,
-        ConstraintMatrix &,
+        AffineConstraints<double> &,
         const ComponentMask &);
     \}
 #endif
@@ -177,7 +177,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const std::map<types::boundary_id,
                        const Function<deal_II_dimension, double> *> &,
         const Quadrature<deal_II_dimension - 1> &,
-        ConstraintMatrix &,
+        AffineConstraints<double> &,
         std::vector<unsigned int>);
 
       template void
@@ -186,7 +186,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const std::map<types::boundary_id,
                        const Function<deal_II_dimension, double> *> &,
         const Quadrature<deal_II_dimension - 1> &,
-        ConstraintMatrix &,
+        AffineConstraints<double> &,
         std::vector<unsigned int>);
 
 #  if deal_II_dimension != 1
@@ -196,7 +196,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const unsigned int,
         const Function<deal_II_dimension> &,
         const types::boundary_id,
-        ConstraintMatrix &,
+        AffineConstraints<double> &,
         const Mapping<deal_II_dimension> &);
       template void
       project_boundary_values_curl_conforming<deal_II_dimension>(
@@ -204,7 +204,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const unsigned int,
         const Function<deal_II_dimension> &,
         const types::boundary_id,
-        ConstraintMatrix &,
+        AffineConstraints<double> &,
         const hp::MappingCollection<deal_II_dimension> &);
       template void
       project_boundary_values_curl_conforming_l2<deal_II_dimension>(
@@ -212,7 +212,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const unsigned int,
         const Function<deal_II_dimension> &,
         const types::boundary_id,
-        ConstraintMatrix &,
+        AffineConstraints<double> &,
         const Mapping<deal_II_dimension> &);
       template void
       project_boundary_values_curl_conforming_l2<deal_II_dimension>(
@@ -220,7 +220,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const unsigned int,
         const Function<deal_II_dimension> &,
         const types::boundary_id,
-        ConstraintMatrix &,
+        AffineConstraints<double> &,
         const hp::MappingCollection<deal_II_dimension> &);
       template void
       project_boundary_values_div_conforming<deal_II_dimension>(
@@ -228,7 +228,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const unsigned int,
         const Function<deal_II_dimension> &,
         const types::boundary_id,
-        ConstraintMatrix &,
+        AffineConstraints<double> &,
         const Mapping<deal_II_dimension> &);
       template void
       project_boundary_values_div_conforming<deal_II_dimension>(
@@ -236,7 +236,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const unsigned int,
         const Function<deal_II_dimension> &,
         const types::boundary_id,
-        ConstraintMatrix &,
+        AffineConstraints<double> &,
         const hp::MappingCollection<deal_II_dimension> &);
 #  endif
 #endif
index eb6833d4fcc4ee19eeaa4ccda926c35dc9ca589c..2d6b205c1ec5ba0ad325eea09bef521d034e44d8 100644 (file)
@@ -30,7 +30,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const unsigned int                    first_vector_component,
         const std::set<types::boundary_id> &  boundary_ids,
         FunctionMap<deal_II_dimension>::type &function_map,
-        ConstraintMatrix &                    constraints,
+        AffineConstraints<double> &           constraints,
         const Mapping<deal_II_dimension> &    mapping);
 
       template void
@@ -39,7 +39,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const unsigned int                       first_vector_component,
         const std::set<types::boundary_id> &     boundary_ids,
         FunctionMap<deal_II_dimension>::type &   function_map,
-        ConstraintMatrix &                       constraints,
+        AffineConstraints<double> &              constraints,
         const Mapping<deal_II_dimension> &       mapping);
 
       template void
@@ -48,7 +48,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const unsigned int                    first_vector_component,
         const std::set<types::boundary_id> &  boundary_ids,
         FunctionMap<deal_II_dimension>::type &function_map,
-        ConstraintMatrix &                    constraints,
+        AffineConstraints<double> &           constraints,
         const Mapping<deal_II_dimension> &    mapping);
       template void
       compute_nonzero_tangential_flux_constraints(
@@ -56,7 +56,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const unsigned int                       first_vector_component,
         const std::set<types::boundary_id> &     boundary_ids,
         FunctionMap<deal_II_dimension>::type &   function_map,
-        ConstraintMatrix &                       constraints,
+        AffineConstraints<double> &              constraints,
         const Mapping<deal_II_dimension> &       mapping);
 
       template void
@@ -64,7 +64,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const DoFHandler<deal_II_dimension> &dof_handler,
         const unsigned int                   first_vector_component,
         const std::set<types::boundary_id> & boundary_ids,
-        ConstraintMatrix &                   constraints,
+        AffineConstraints<double> &          constraints,
         const Mapping<deal_II_dimension> &   mapping);
 
       template void
@@ -72,7 +72,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const hp::DoFHandler<deal_II_dimension> &dof_handler,
         const unsigned int                       first_vector_component,
         const std::set<types::boundary_id> &     boundary_ids,
-        ConstraintMatrix &                       constraints,
+        AffineConstraints<double> &              constraints,
         const Mapping<deal_II_dimension> &       mapping);
 
       template void
@@ -80,7 +80,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const DoFHandler<deal_II_dimension> &dof_handler,
         const unsigned int                   first_vector_component,
         const std::set<types::boundary_id> & boundary_ids,
-        ConstraintMatrix &                   constraints,
+        AffineConstraints<double> &          constraints,
         const Mapping<deal_II_dimension> &   mapping);
 
       template void
@@ -88,7 +88,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const hp::DoFHandler<deal_II_dimension> &dof_handler,
         const unsigned int                       first_vector_component,
         const std::set<types::boundary_id> &     boundary_ids,
-        ConstraintMatrix &                       constraints,
+        AffineConstraints<double> &              constraints,
         const Mapping<deal_II_dimension> &       mapping);
 #  endif
 #endif
index 59d5ab794c15a17286f0d8b2609f3bf3015c9633..53d8fef3dd24fac7df383dc10084ef9afd4ff627 100644 (file)
@@ -122,7 +122,7 @@ for (VEC : VECTOR_TYPES; deal_II_dimension : DIMENSIONS;
         const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
         const VEC &,
         const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
-        const ConstraintMatrix &,
+        const AffineConstraints<VEC::value_type> &,
         VEC &);
 
       template void
@@ -130,7 +130,7 @@ for (VEC : VECTOR_TYPES; deal_II_dimension : DIMENSIONS;
         const InterGridMap<
           DoFHandler<deal_II_dimension, deal_II_space_dimension>> &,
         const VEC &,
-        const ConstraintMatrix &,
+        const AffineConstraints<VEC::value_type> &,
         VEC &);
     \}
 #endif
index f71c34a37e5f995d81d18ca6ecf15aea70947af0..cf739844048f152fdf57de58c2c448008ffb95cf 100644 (file)
@@ -25,7 +25,7 @@ for (VEC : REAL_VECTOR_TYPES; deal_II_dimension : DIMENSIONS;
       project<deal_II_dimension, VEC, deal_II_space_dimension>(
         const Mapping<deal_II_dimension, deal_II_space_dimension> &,
         const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
-        const ConstraintMatrix &,
+        const AffineConstraints<VEC::value_type> &,
         const Quadrature<deal_II_dimension> &,
         const Function<deal_II_space_dimension, VEC::value_type> &,
         VEC &,
@@ -36,7 +36,7 @@ for (VEC : REAL_VECTOR_TYPES; deal_II_dimension : DIMENSIONS;
       template void
       project<deal_II_dimension, VEC, deal_II_space_dimension>(
         const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
-        const ConstraintMatrix &,
+        const AffineConstraints<VEC::value_type> &,
         const Quadrature<deal_II_dimension> &,
         const Function<deal_II_space_dimension, VEC::value_type> &,
         VEC &,
index fc51d36cc9d8434653a18224a6974ec28e8a6d0e..a3c87c347588a3e4efa7bab6349e2c42a8608d3e 100644 (file)
@@ -25,7 +25,7 @@ for (VEC : REAL_VECTOR_TYPES; deal_II_dimension : DIMENSIONS;
       project<deal_II_dimension, VEC, deal_II_space_dimension>(
         const Mapping<deal_II_dimension, deal_II_space_dimension> &,
         const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
-        const ConstraintMatrix &,
+        const AffineConstraints<VEC::value_type> &,
         const Quadrature<deal_II_dimension> &,
         const Function<deal_II_space_dimension, VEC::value_type> &,
         VEC &,
@@ -36,7 +36,7 @@ for (VEC : REAL_VECTOR_TYPES; deal_II_dimension : DIMENSIONS;
       template void
       project<deal_II_dimension, VEC, deal_II_space_dimension>(
         const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
-        const ConstraintMatrix &,
+        const AffineConstraints<VEC::value_type> &,
         const Quadrature<deal_II_dimension> &,
         const Function<deal_II_space_dimension, VEC::value_type> &,
         VEC &,
index 9421dd4b1bb08e7f62824ed946699961e3568f08..96f2259bf4b62189811fe319dfba714756b81f6e 100644 (file)
@@ -26,7 +26,7 @@ for (VEC : REAL_VECTOR_TYPES; deal_II_dimension : DIMENSIONS;
         const hp::MappingCollection<deal_II_dimension, deal_II_space_dimension>
           &,
         const hp::DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
-        const ConstraintMatrix &,
+        const AffineConstraints<VEC::value_type> &,
         const hp::QCollection<deal_II_dimension> &,
         const Function<deal_II_space_dimension, VEC::value_type> &,
         VEC &,
@@ -37,7 +37,7 @@ for (VEC : REAL_VECTOR_TYPES; deal_II_dimension : DIMENSIONS;
       template void
       project(
         const hp::DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
-        const ConstraintMatrix &,
+        const AffineConstraints<VEC::value_type> &,
         const hp::QCollection<deal_II_dimension> &,
         const Function<deal_II_space_dimension, VEC::value_type> &,
         VEC &,
index 767255686cfb1816c36d30b3b79e5080530d28a8..0cc45473719b67ef1c64675b82cad8f047f4730c 100644 (file)
@@ -22,7 +22,7 @@ for (VEC : REAL_NONBLOCK_VECTORS; deal_II_dimension : DIMENSIONS)
       project<deal_II_dimension, VEC, deal_II_dimension>(
         const Mapping<deal_II_dimension, deal_II_dimension> &,
         const DoFHandler<deal_II_dimension, deal_II_dimension> &,
-        const ConstraintMatrix &,
+        const AffineConstraints<VEC::value_type> &,
         const Quadrature<deal_II_dimension> &,
         const std::function<VEC::value_type(
           const DoFHandler<deal_II_dimension,
index 34179ac078a17b22f4abff0a4a41c315d3684fe0..9e9f4085049b3965b1653e8510e8d627f6e46f92 100644 (file)
@@ -23,8 +23,8 @@ for (VEC : REAL_NONBLOCK_VECTORS; deal_II_dimension : DIMENSIONS)
       template void
       project<deal_II_dimension, VEC>(
         std::shared_ptr<const MatrixFree<deal_II_dimension, VEC::value_type>>
-                                matrix_free,
-        const ConstraintMatrix &constraints,
+                                                  matrix_free,
+        const AffineConstraints<VEC::value_type> &constraints,
         const std::function<VectorizedArray<
           VEC::value_type>(const unsigned int, const unsigned int)> &,
         VEC &,
@@ -33,8 +33,8 @@ for (VEC : REAL_NONBLOCK_VECTORS; deal_II_dimension : DIMENSIONS)
       template void
       project<deal_II_dimension, VEC>(
         std::shared_ptr<const MatrixFree<deal_II_dimension, VEC::value_type>>
-                                matrix_free,
-        const ConstraintMatrix &constraints,
+                                                  matrix_free,
+        const AffineConstraints<VEC::value_type> &constraints,
         const unsigned int,
         const std::function<VectorizedArray<
           VEC::value_type>(const unsigned int, const unsigned int)> &,
index 54d58792ba6abfbb6ab2c4d836c0d77fd3bc16f4..1288f5e5b1a33fd4099ae04b162632a6d6faf265 100644 (file)
@@ -27,7 +27,7 @@ for (VEC : REAL_VECTOR_TYPES; deal_II_dimension : DIMENSIONS;
         const Quadrature<deal_II_dimension> &,
         const Function<deal_II_space_dimension, VEC::value_type> &,
         VEC &,
-        const ConstraintMatrix &);
+        const AffineConstraints<VEC::value_type> &);
 
       template void
       create_right_hand_side<deal_II_dimension, deal_II_space_dimension, VEC>(
@@ -35,7 +35,7 @@ for (VEC : REAL_VECTOR_TYPES; deal_II_dimension : DIMENSIONS;
         const Quadrature<deal_II_dimension> &,
         const Function<deal_II_space_dimension, VEC::value_type> &,
         VEC &,
-        const ConstraintMatrix &);
+        const AffineConstraints<VEC::value_type> &);
     \}
 #endif
   }
@@ -58,7 +58,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const hp::QCollection<deal_II_dimension> &,
         const Function<deal_II_space_dimension, Vector<double>::value_type> &,
         Vector<double> &,
-        const ConstraintMatrix &);
+        const AffineConstraints<double> &);
 
       template void
       create_right_hand_side<deal_II_dimension,
@@ -68,7 +68,7 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
         const hp::QCollection<deal_II_dimension> &,
         const Function<deal_II_space_dimension, Vector<double>::value_type> &,
         Vector<double> &,
-        const ConstraintMatrix &);
+        const AffineConstraints<double> &);
 
 #  if deal_II_dimension > 1
       template void

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.