Remove deprecated variant of DoFTools::make_sparsity_pattern with a vector-of-vector...

diff --git a/doc/news/changes.h b/doc/news/changes.h
index 930bb82e47a7bf48bd0e7a6f549f124d6eeda2fd..55df560decac3984527e859dd1f68d6464abd94a 100644 (file)
--- a/doc/news/changes.h
+++ b/doc/news/changes.h
@@ -73,6 +73,7 @@ inconvenience this causes.
     library to the muparser library after the deal.II 8.1 release).
   - DoFRenumbering::downstream_dg.
   - DoFTools::count_dofs_per_component.
+  - DoFTools::make_sparsity_pattern with a vector-of-vector mask.
 </ol>
 
   <li> Removed: The config.h file no longer exports HAVE_* definitions.

diff --git a/include/deal.II/dofs/dof_tools.h b/include/deal.II/dofs/dof_tools.h
index 47419c1ab77b8a6264f2e9f52f8cd453e1167032..a545b4c5fab63f301b3cf9694d6f6545d807d6fa 100644 (file)
--- a/include/deal.II/dofs/dof_tools.h
+++ b/include/deal.II/dofs/dof_tools.h
@@ -499,18 +499,6 @@ namespace DoFTools
                          const bool                keep_constrained_dofs = true,
                          const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id);
 
-  /**
-   * @deprecated This is the old form of the previous function. It generates a
-   * table of DoFTools::Coupling values (where a <code>true</code> value in
-   * the mask is translated into a Coupling::always value in the table) and
-   * calls the function above.
-   */
-  template <class DH, class SparsityPattern>
-  void
-  make_sparsity_pattern (const DH                              &dof,
-                         const std::vector<std::vector<bool> > &mask,
-                         SparsityPattern                       &sparsity_pattern) DEAL_II_DEPRECATED;
-
   /**
    * Construct a sparsity pattern that allows coupling degrees of freedom on
    * two different but related meshes.
@@ -2355,34 +2343,6 @@ namespace DoFTools
   }
 
 
-  template <class DH, class SparsityPattern>
-  inline
-  void
-  make_sparsity_pattern (const DH                              &dof,
-                         const std::vector<std::vector<bool> > &mask,
-                         SparsityPattern                       &sparsity_pattern)
-  {
-    const unsigned int ncomp = dof.get_fe().n_components();
-
-    Assert (mask.size() == ncomp,
-            ExcDimensionMismatch(mask.size(), ncomp));
-    for (unsigned int i=0; i<mask.size(); ++i)
-      Assert (mask[i].size() == ncomp,
-              ExcDimensionMismatch(mask[i].size(), ncomp));
-    // Create a coupling table out of the mask
-    Table<2,DoFTools::Coupling> couplings(ncomp, ncomp);
-    for (unsigned int i=0; i<ncomp; ++i)
-      for (unsigned int j=0; j<ncomp; ++j)
-        if (mask[i][j])
-          couplings(i,j) = always;
-        else
-          couplings(i,j) = none;
-
-    // Call the new function
-    make_sparsity_pattern(dof, couplings, sparsity_pattern);
-  }
-
-
   template <class DH, class Comp>
   void
   map_support_points_to_dofs (

diff --git a/tests/bits/dof_tools_02a.cc b/tests/bits/dof_tools_02a.cc
index b646d55bdcae35092f77d1cf78ee612ed1552e85..f2a5a5283c553a51aec15f678b57d0cf954fee8a 100644 (file)
--- a/tests/bits/dof_tools_02a.cc
+++ b/tests/bits/dof_tools_02a.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -21,7 +21,7 @@
 // check
 //   DoFTools::
 //   make_sparsity_pattern (const DoFHandler<dim> &,
-//                          std::vector<std::vector<bool> > &,
+//                          Table<2,DoFTools::Coupling> &,
 //                      SparsityPattern       &);
 
 
@@ -34,10 +34,12 @@ check_this (const DoFHandler<dim> &dof_handler)
 {
   // set up X-shape mask
   const unsigned int n_components = dof_handler.get_fe().n_components();
-  std::vector<std::vector<bool> > mask (n_components,
-                                        std::vector<bool>(n_components,false));
+  Table<2,DoFTools::Coupling> mask (n_components, n_components);
   for (unsigned int i=0; i<n_components; ++i)
-    mask[i][i] = mask[i][n_components-i-1] = true;
+    for (unsigned int j=0; j<n_components; ++j)
+      mask(i,j) = DoFTools::none;
+  for (unsigned int i=0; i<n_components; ++i)
+    mask[i][i] = mask[i][n_components-i-1] = DoFTools::always;
 
   // create sparsity pattern
   SparsityPattern sp (dof_handler.n_dofs(),

diff --git a/tests/bits/dof_tools_02a_constraints_true.cc b/tests/bits/dof_tools_02a_constraints_true.cc
index 57dd2b40f11fddbc33dba1cc2365907e575d0861..4d6b9ca76fc542cbc8a21b7bc2d966a0c07ca558 100644 (file)
--- a/tests/bits/dof_tools_02a_constraints_true.cc
+++ b/tests/bits/dof_tools_02a_constraints_true.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -21,7 +21,7 @@
 // check
 //   DoFTools::
 //   make_sparsity_pattern (const DoFHandler<dim> &,
-//                          std::vector<std::vector<bool> > &,
+//                          Table<2,DoFTools::Coupling> &,
 //                      SparsityPattern       &,
 //                          ConstraintMatrix,
 //                          true);

diff --git a/tests/bits/dof_tools_02b.cc b/tests/bits/dof_tools_02b.cc
index 3d763018d6674402fc6e2a69bae4eddd28861137..1cff78af7016627aabc6cbfe77d389be8a93bfcb 100644 (file)
--- a/tests/bits/dof_tools_02b.cc
+++ b/tests/bits/dof_tools_02b.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -21,7 +21,7 @@
 // check
 //   DoFTools::
 //   make_sparsity_pattern (const DoFHandler<dim>     &,
-//                          std::vector<std::vector<bool> > &,
+//                          Table<2,Coupling> &,
 //                      CompressedSparsityPattern &);
 
 std::string output_file_name = "output";
@@ -33,10 +33,12 @@ check_this (const DoFHandler<dim> &dof_handler)
 {
   // set up X-shape mask
   const unsigned int n_components = dof_handler.get_fe().n_components();
-  std::vector<std::vector<bool> > mask (n_components,
-                                        std::vector<bool>(n_components,false));
+  Table<2,DoFTools::Coupling> mask (n_components, n_components);
   for (unsigned int i=0; i<n_components; ++i)
-    mask[i][i] = mask[i][n_components-i-1] = true;
+    for (unsigned int j=0; j<n_components; ++j)
+      mask(i,j) = DoFTools::none;
+  for (unsigned int i=0; i<n_components; ++i)
+    mask[i][i] = mask[i][n_components-i-1] = DoFTools::always;
 
   // create sparsity pattern
   CompressedSparsityPattern sp (dof_handler.n_dofs());

diff --git a/tests/bits/dof_tools_02b_x.cc b/tests/bits/dof_tools_02b_x.cc
index f80d6720985fe7e558e77998976bda79c755b049..d018216d65e5b45e316a1583b1317f6c49c2df4a 100644 (file)
--- a/tests/bits/dof_tools_02b_x.cc
+++ b/tests/bits/dof_tools_02b_x.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,10 +33,12 @@ check_this (const DoFHandler<dim> &dof_handler)
 {
   // set up X-shape mask
   const unsigned int n_components = dof_handler.get_fe().n_components();
-  std::vector<std::vector<bool> > mask (n_components,
-                                        std::vector<bool>(n_components,false));
+  Table<2,DoFTools::Coupling> mask (n_components, n_components);
   for (unsigned int i=0; i<n_components; ++i)
-    mask[i][i] = mask[i][n_components-i-1] = true;
+    for (unsigned int j=0; j<n_components; ++j)
+      mask(i,j) = DoFTools::none;
+  for (unsigned int i=0; i<n_components; ++i)
+    mask[i][i] = mask[i][n_components-i-1] = DoFTools::always;
 
   // create sparsity pattern
   CompressedSetSparsityPattern sp (dof_handler.n_dofs());

diff --git a/tests/bits/dof_tools_02c.cc b/tests/bits/dof_tools_02c.cc
index 211190aade608beb4953c5a80e4731920426e4d5..dd8016319340acddecc2646de307990f670d0b50 100644 (file)
--- a/tests/bits/dof_tools_02c.cc
+++ b/tests/bits/dof_tools_02c.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -21,7 +21,7 @@
 // check
 //   DoFTools::
 //   make_sparsity_pattern (const DoFHandler<dim> &,
-//                          std::vector<std::vector<bool> > &,
+//                          Table<2,Coupling> &,
 //                      BlockSparsityPattern  &);
 
 std::string output_file_name = "output";
@@ -33,10 +33,12 @@ check_this (const DoFHandler<dim> &dof_handler)
 {
   // set up X-shape mask
   const unsigned int n_components = dof_handler.get_fe().n_components();
-  std::vector<std::vector<bool> > mask (n_components,
-                                        std::vector<bool>(n_components,false));
+  Table<2,DoFTools::Coupling> mask (n_components, n_components);
   for (unsigned int i=0; i<n_components; ++i)
-    mask[i][i] = mask[i][n_components-i-1] = true;
+    for (unsigned int j=0; j<n_components; ++j)
+      mask(i,j) = DoFTools::none;
+  for (unsigned int i=0; i<n_components; ++i)
+    mask[i][i] = mask[i][n_components-i-1] = DoFTools::always;
 
   // we split up the matrix into
   // blocks according to the number

diff --git a/tests/bits/dof_tools_02d.cc b/tests/bits/dof_tools_02d.cc
index 176144fd6d2fa0fc651c7848bc400c3e3b0d7785..5c3f88b3ff192b3e66831ec273b658750634b179 100644 (file)
--- a/tests/bits/dof_tools_02d.cc
+++ b/tests/bits/dof_tools_02d.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,10 +33,12 @@ check_this (const DoFHandler<dim> &dof_handler)
 {
   // set up X-shape mask
   const unsigned int n_components = dof_handler.get_fe().n_components();
-  std::vector<std::vector<bool> > mask (n_components,
-                                        std::vector<bool>(n_components,false));
+  Table<2,DoFTools::Coupling> mask (n_components, n_components);
   for (unsigned int i=0; i<n_components; ++i)
-    mask[i][i] = mask[i][n_components-i-1] = true;
+    for (unsigned int j=0; j<n_components; ++j)
+      mask(i,j) = DoFTools::none;
+  for (unsigned int i=0; i<n_components; ++i)
+    mask[i][i] = mask[i][n_components-i-1] = DoFTools::always;
 
   // we split up the matrix into
   // blocks according to the number

diff --git a/tests/bits/dof_tools_02d_x.cc b/tests/bits/dof_tools_02d_x.cc
index 1ddfb76a2c6d5ac9324cc2dc04961fc8fd70413c..79a5e49821e63dee1664adbdec1b250c1aeb4f46 100644 (file)
--- a/tests/bits/dof_tools_02d_x.cc
+++ b/tests/bits/dof_tools_02d_x.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -21,7 +21,7 @@
 // check
 //   DoFTools::
 //   make_sparsity_pattern (const DoFHandler<dim> &,
-//                          std::vector<std::vector<bool> > &,
+//                          Table<2,Coupling> &,
 //                      BlockCompressedSetSparsityPattern  &);
 
 std::string output_file_name = "output";
@@ -33,10 +33,12 @@ check_this (const DoFHandler<dim> &dof_handler)
 {
   // set up X-shape mask
   const unsigned int n_components = dof_handler.get_fe().n_components();
-  std::vector<std::vector<bool> > mask (n_components,
-                                        std::vector<bool>(n_components,false));
+  Table<2,DoFTools::Coupling> mask (n_components, n_components);
   for (unsigned int i=0; i<n_components; ++i)
-    mask[i][i] = mask[i][n_components-i-1] = true;
+    for (unsigned int j=0; j<n_components; ++j)
+      mask(i,j) = DoFTools::none;
+  for (unsigned int i=0; i<n_components; ++i)
+    mask[i][i] = mask[i][n_components-i-1] = DoFTools::always;
 
   // we split up the matrix into
   // blocks according to the number

diff --git a/tests/deal.II/create_laplace_matrix_02.cc b/tests/deal.II/create_laplace_matrix_02.cc
index dcc03ed38ec56712c1760b01c9c8ae88cb577d79..0e35a4b9015681cc99b33c2525e2ae6b62aa262d 100644 (file)
--- a/tests/deal.II/create_laplace_matrix_02.cc
+++ b/tests/deal.II/create_laplace_matrix_02.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -83,8 +83,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/deal.II/create_laplace_matrix_02b.cc b/tests/deal.II/create_laplace_matrix_02b.cc
index f42fb8327711b8600f6220f1754c91524f0244aa..59217a736cdc5cc968cfeea997d84091e18d6081 100644 (file)
--- a/tests/deal.II/create_laplace_matrix_02b.cc
+++ b/tests/deal.II/create_laplace_matrix_02b.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -84,8 +84,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/deal.II/create_laplace_matrix_04.cc b/tests/deal.II/create_laplace_matrix_04.cc
index 530f53465bbf21a86c91a2bfdc346f76c4c704cd..91424be6d1bc92225fc80a84b309e3af093bacbc 100644 (file)
--- a/tests/deal.II/create_laplace_matrix_04.cc
+++ b/tests/deal.II/create_laplace_matrix_04.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -82,8 +82,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/deal.II/create_laplace_matrix_04b.cc b/tests/deal.II/create_laplace_matrix_04b.cc
index 3ef8d4f0eddd94647812c711277401cbe4249332..1b0ea1ccc5fea58a3e4ccf1d3940d6c99eb73457 100644 (file)
--- a/tests/deal.II/create_laplace_matrix_04b.cc
+++ b/tests/deal.II/create_laplace_matrix_04b.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -83,8 +83,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/deal.II/create_mass_matrix_02.cc b/tests/deal.II/create_mass_matrix_02.cc
index f64faf8ca216d37d7253842860edbc0205621210..06ac3a863c9c257dc4e61dcdabfb19e49382ba91 100644 (file)
--- a/tests/deal.II/create_mass_matrix_02.cc
+++ b/tests/deal.II/create_mass_matrix_02.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -83,8 +83,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/deal.II/create_mass_matrix_02b.cc b/tests/deal.II/create_mass_matrix_02b.cc
index 4186fc10cd4e9b243c1c0b6e5a51ccfcbb685214..d0da9799d7446be0d5a728100b686eaeca734bf7 100644 (file)
--- a/tests/deal.II/create_mass_matrix_02b.cc
+++ b/tests/deal.II/create_mass_matrix_02b.cc
@@ -84,8 +84,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/deal.II/create_mass_matrix_04.cc b/tests/deal.II/create_mass_matrix_04.cc
index d0cf3084813ef11941873855f2e0011044835072..2d3ff084760e2113219fe47c9c54a85221981e1a 100644 (file)
--- a/tests/deal.II/create_mass_matrix_04.cc
+++ b/tests/deal.II/create_mass_matrix_04.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -82,8 +82,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/deal.II/create_mass_matrix_04b.cc b/tests/deal.II/create_mass_matrix_04b.cc
index 3a30f963fee5c975d1c8f1705bb0bf03d5862284..3683b921d2a5c8e2194dcc0e586af0d850a1c8ef 100644 (file)
--- a/tests/deal.II/create_mass_matrix_04b.cc
+++ b/tests/deal.II/create_mass_matrix_04b.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -83,8 +83,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/deal.II/create_mass_matrix_05.cc b/tests/deal.II/create_mass_matrix_05.cc
index e0b2211b074c796859402d2ee2239fab2517aef6..d437a718a16726c6daf18adfce893ced2d5ab9dd 100644 (file)
--- a/tests/deal.II/create_mass_matrix_05.cc
+++ b/tests/deal.II/create_mass_matrix_05.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -74,14 +74,17 @@ check ()
   // that different blocks should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (dim*2,
-                                        std::vector<bool>(dim*2, false));
+  const unsigned int n_components = 2*dim;
+  Table<2,DoFTools::Coupling> mask (n_components, n_components);
+  for (unsigned int i=0; i<n_components; ++i)
+    for (unsigned int j=0; j<n_components; ++j)
+      mask(i,j) = DoFTools::none;
   for (unsigned int i=0; i<dim; ++i)
     for (unsigned int j=0; j<dim; ++j)
-      mask[i][j] = true;
+      mask[i][j] = DoFTools::always;
   for (unsigned int i=0; i<dim; ++i)
     for (unsigned int j=0; j<dim; ++j)
-      mask[dim+i][dim+j] = true;
+      mask[dim+i][dim+j] = DoFTools::always;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/deal.II/matrices.cc b/tests/deal.II/matrices.cc
index 9822105eb69125191136e0ef65eb5f55baa12b12..e5519131b5837907bdb6265203a18a75008e24e4 100644 (file)
--- a/tests/deal.II/matrices.cc
+++ b/tests/deal.II/matrices.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -154,8 +154,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/deal.II/sparsity_pattern.cc b/tests/deal.II/sparsity_pattern.cc
index d728836c878427dc66cd150166a74bc1a213ab8b..726c750530e9df4c5eb596f0f36ae13b77dd89f5 100644 (file)
--- a/tests/deal.II/sparsity_pattern.cc
+++ b/tests/deal.II/sparsity_pattern.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -127,8 +127,9 @@ check ()
   // create sparsity pattern. note
   // that different components should
   // not couple, so use pattern
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
 
 
 //--------------- Regular sparsity pattern checks -----------------

diff --git a/tests/deal.II/sparsity_pattern_01.cc b/tests/deal.II/sparsity_pattern_01.cc
index 4993baf75960e38136df2a37ed19a18462003d48..22f11007be72380d5b580ffcc76ed47cba186f54 100644 (file)
--- a/tests/deal.II/sparsity_pattern_01.cc
+++ b/tests/deal.II/sparsity_pattern_01.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -126,8 +126,9 @@ check ()
   // create sparsity pattern. note
   // that different components should
   // not couple, so use pattern
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
 
 
 //--------------- Regular sparsity pattern checks -----------------

diff --git a/tests/deal.II/sparsity_pattern_01_x.cc b/tests/deal.II/sparsity_pattern_01_x.cc
index 206e83273963b7aa7e3036d4a067b0ae391b91e7..2a514b09e42bead3059bf0bb55d89a4253084ce6 100644 (file)
--- a/tests/deal.II/sparsity_pattern_01_x.cc
+++ b/tests/deal.II/sparsity_pattern_01_x.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -127,8 +127,9 @@ check ()
   // create sparsity pattern. note
   // that different components should
   // not couple, so use pattern
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
 
 
 //--------------- Regular sparsity pattern checks -----------------

diff --git a/tests/deal.II/sparsity_pattern_x.cc b/tests/deal.II/sparsity_pattern_x.cc
index 72e6deb960ed627c3525745f8c1bbe1bbc0e7180..a30400ab99ed28cfd81792620ecc91f681da55af 100644 (file)
--- a/tests/deal.II/sparsity_pattern_x.cc
+++ b/tests/deal.II/sparsity_pattern_x.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -127,8 +127,9 @@ check ()
   // create sparsity pattern. note
   // that different components should
   // not couple, so use pattern
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
 
 
 //--------------- Regular sparsity pattern checks -----------------

diff --git a/tests/fe/non_primitive_1.cc b/tests/fe/non_primitive_1.cc
index c6776ee6a293681a142afacdf755899c5a42c009..4983cb6b6807634b48b5a825bf072025e3523e58 100644 (file)
--- a/tests/fe/non_primitive_1.cc
+++ b/tests/fe/non_primitive_1.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2001 - 2013 by the deal.II authors
+// Copyright (C) 2001 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -295,8 +295,11 @@ test ()
   // for the stokes equation the
   // pressure does not couple to
   // itself
-  std::vector<std::vector<bool> > mask (dim+1, std::vector<bool> (dim+1, true));
-  mask[dim][dim] = false;
+  Table<2,DoFTools::Coupling> mask (dim+1, dim+1);
+  for (unsigned int i=0; i<dim+1; ++i)
+    for (unsigned int j=0; j<dim+1; ++j)
+      mask(i,j) = DoFTools::always;
+  mask[dim][dim] = DoFTools::none;
 
   DoFTools::make_sparsity_pattern (dof_handler, mask, sparsity);
   sparsity.compress ();

diff --git a/tests/hp/create_laplace_matrix_02.cc b/tests/hp/create_laplace_matrix_02.cc
index 7550dccdadd255e99e8149cbe7739de982f725b6..7b0dfc3bfa6af3c1b565f65da39457ef2fc7e02d 100644 (file)
--- a/tests/hp/create_laplace_matrix_02.cc
+++ b/tests/hp/create_laplace_matrix_02.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -96,8 +96,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/hp/create_laplace_matrix_02b.cc b/tests/hp/create_laplace_matrix_02b.cc
index cc389f1623b71a7ed4b805ea55411e1181268e37..a0cd137f23f848f13ccc073ec978aeb801d29b02 100644 (file)
--- a/tests/hp/create_laplace_matrix_02b.cc
+++ b/tests/hp/create_laplace_matrix_02b.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -97,8 +97,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/hp/create_laplace_matrix_04.cc b/tests/hp/create_laplace_matrix_04.cc
index 8c9f0f1adb4bad5793f97e57f8140a44da68d8e2..0458600dee625e47d5fbdb82be4b5655fe4643ba 100644 (file)
--- a/tests/hp/create_laplace_matrix_04.cc
+++ b/tests/hp/create_laplace_matrix_04.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -95,8 +95,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/hp/create_laplace_matrix_04b.cc b/tests/hp/create_laplace_matrix_04b.cc
index 0b0f0f491f68ebff78c6a1be026a7f5cf4da002d..a0f7068e00ec8d3d3fd858ea4c89e7c3efa90204 100644 (file)
--- a/tests/hp/create_laplace_matrix_04b.cc
+++ b/tests/hp/create_laplace_matrix_04b.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -96,8 +96,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/hp/create_mass_matrix_02.cc b/tests/hp/create_mass_matrix_02.cc
index 286a6474f10f5129dfcfd754829fc2215d99546d..bb4531b31d28e17c223512ad7a5dd1078de968f8 100644 (file)
--- a/tests/hp/create_mass_matrix_02.cc
+++ b/tests/hp/create_mass_matrix_02.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -96,8 +96,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/hp/create_mass_matrix_02b.cc b/tests/hp/create_mass_matrix_02b.cc
index e66b14a6171dde4940701690bede77a817bb5270..9f456f700f072470d7b22afc7c1a53ca49d4a2ee 100644 (file)
--- a/tests/hp/create_mass_matrix_02b.cc
+++ b/tests/hp/create_mass_matrix_02b.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -97,8 +97,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/hp/create_mass_matrix_04.cc b/tests/hp/create_mass_matrix_04.cc
index 08bbf6fc8d18c3ad258bd7c607ec80064e0aa607..30962f1aae34d04a2dbfb01931ceae8c70e5b3dc 100644 (file)
--- a/tests/hp/create_mass_matrix_04.cc
+++ b/tests/hp/create_mass_matrix_04.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -95,8 +95,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/hp/create_mass_matrix_04b.cc b/tests/hp/create_mass_matrix_04b.cc
index cbca58c73ec19b0f1530d317926b13a1f2952151..1533782d4d618afcccebe435a5ebd55a606f04fc 100644 (file)
--- a/tests/hp/create_mass_matrix_04b.cc
+++ b/tests/hp/create_mass_matrix_04b.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -96,8 +96,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/hp/create_mass_matrix_05.cc b/tests/hp/create_mass_matrix_05.cc
index 3d46bfd79e2bb95a1a1b558f1819c11a40f11842..719a5649043d9dd495984ae19472e03213a79aea 100644 (file)
--- a/tests/hp/create_mass_matrix_05.cc
+++ b/tests/hp/create_mass_matrix_05.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -89,14 +89,16 @@ check ()
   // that different blocks should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (dim*2,
-                                        std::vector<bool>(dim*2, false));
+  Table<2,DoFTools::Coupling> mask (2*dim, 2*dim);
+  for (unsigned int i=0; i<2*dim; ++i)
+    for (unsigned int j=0; j<2*dim; ++j)
+      mask[i][j] = DoFTools::none;
   for (unsigned int i=0; i<dim; ++i)
     for (unsigned int j=0; j<dim; ++j)
-      mask[i][j] = true;
+      mask[i][j] = DoFTools::always;
   for (unsigned int i=0; i<dim; ++i)
     for (unsigned int j=0; j<dim; ++j)
-      mask[dim+i][dim+j] = true;
+      mask[dim+i][dim+j] = DoFTools::always;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
 
   ConstraintMatrix constraints;

diff --git a/tests/hp/matrices.cc b/tests/hp/matrices.cc
index d7e55eefd58076766d9a7133e6b30c414543f133..6b7687d24faef271aeb19994ac51d5378a2a7653 100644 (file)
--- a/tests/hp/matrices.cc
+++ b/tests/hp/matrices.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -163,8 +163,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);

diff --git a/tests/hp/matrices_hp.cc b/tests/hp/matrices_hp.cc
index 309b988e402042541d0309f60f1b9252d760a967..b4a40a8634beaa375090c725c635af9f9d97ae53 100644 (file)
--- a/tests/hp/matrices_hp.cc
+++ b/tests/hp/matrices_hp.cc
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -169,8 +169,9 @@ check ()
   // that different components should
   // not couple, so use pattern
   SparsityPattern sparsity (dof.n_dofs(), dof.n_dofs());
-  std::vector<std::vector<bool> > mask (2, std::vector<bool>(2, false));
-  mask[0][0] = mask[1][1] = true;
+  Table<2,DoFTools::Coupling> mask (2, 2);
+  mask(0,0) = mask(1,1) = DoFTools::always;
+  mask(0,1) = mask(1,0) = DoFTools::none;
   DoFTools::make_sparsity_pattern (dof, mask, sparsity);
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (dof, constraints);