]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Rework Compressed*SparsityPattern
authorTimo Heister <timo.heister@gmail.com>
Sun, 8 Mar 2015 15:08:31 +0000 (11:08 -0400)
committerTimo Heister <timo.heister@gmail.com>
Sat, 21 Mar 2015 23:09:23 +0000 (19:09 -0400)
- rename CompressedSimpleSparsityPattern to DynamicSparsityPattern
- deprecate all Compressed*SparsityPattern classes
- same for BlockCompressed*SparsityPattern
- update examples
- replace non-dynamic sparsity creation in step-7, 8, 9, 13, 14, 16, 23,
24, 25, 28, 29, 35

Motivation for removing the other compressed objects:
Number of degrees of freedom: 274625
FE_Q<3>(4)
CompressedSimple vmpeak:  749024 rss:  530804 make: 5.99s copy: 3.58s
Compressed       vmpeak:  744880 rss:  526852 make: 8.59s copy: 3.64s
CompressedSet    vmpeak: 3184880 rss: 2966776 make: 92s   copy: 18s

Or in Martin's words:
I remember having looked into compute times for the
DoFTools::make_sparsity_pattern in detail some five years ago and all
benchmarks showed CompressedSimpleSparsityPattern as the fastest of the
three. The internal data structure in CSimpleSP is std::vector, thus
simpler than plain CSP where there is an additional array of length 8
with 'fresh' entries about to be submitted but otherwise very similar.
std::set as used in CSetSP does way too many memory allocations and is
most likely slower than inserting into a sorted vector for almost all
imaginable loads with up to a few hundred entries. In particular for how
we mostly use sparsity patterns where each row gets touched as many
times as we have adjacent elements to that DoF.

Last but not least, CSimpleSP is the only one with the appropriate
infrastructure for parallel distributed computations where rows use an
additional IndexSet argument.

72 files changed:
cmake/config/template-arguments.in
examples/doxygen/compressed_block_sparsity_pattern.cc
examples/step-11/step-11.cc
examples/step-12/step-12.cc
examples/step-13/step-13.cc
examples/step-14/step-14.cc
examples/step-15/step-15.cc
examples/step-16/step-16.cc
examples/step-18/step-18.cc
examples/step-2/step-2.cc
examples/step-20/step-20.cc
examples/step-22/step-22.cc
examples/step-23/step-23.cc
examples/step-24/step-24.cc
examples/step-25/step-25.cc
examples/step-26/step-26.cc
examples/step-27/step-27.cc
examples/step-28/step-28.cc
examples/step-29/step-29.cc
examples/step-3/step-3.cc
examples/step-31/step-31.cc
examples/step-32/step-32.cc
examples/step-33/step-33.cc
examples/step-35/step-35.cc
examples/step-36/step-36.cc
examples/step-38/step-38.cc
examples/step-39/step-39.cc
examples/step-4/step-4.cc
examples/step-40/step-40.cc
examples/step-41/step-41.cc
examples/step-43/step-43.cc
examples/step-44/step-44.cc
examples/step-45/step-45.cc
examples/step-46/step-46.cc
examples/step-47/step-47.cc
examples/step-5/step-5.cc
examples/step-50/step-50.cc
examples/step-51/step-51.cc
examples/step-52/step-52.cc
examples/step-6/step-6.cc
examples/step-7/step-7.cc
examples/step-8/step-8.cc
examples/step-9/step-9.cc
include/deal.II/lac/block_sparsity_pattern.h
include/deal.II/lac/compressed_set_sparsity_pattern.h
include/deal.II/lac/compressed_simple_sparsity_pattern.h
include/deal.II/lac/compressed_sparsity_pattern.h
include/deal.II/lac/constraint_matrix.h
include/deal.II/lac/dynamic_sparsity_pattern.h [new file with mode: 0644]
include/deal.II/lac/generic_linear_algebra.h
include/deal.II/lac/petsc_parallel_block_sparse_matrix.h
include/deal.II/lac/sparsity_pattern.h
include/deal.II/lac/trilinos_block_sparse_matrix.h
include/deal.II/lac/trilinos_sparsity_pattern.h
include/deal.II/matrix_free/dof_info.h
include/deal.II/matrix_free/dof_info.templates.h
source/lac/CMakeLists.txt
source/lac/block_sparsity_pattern.cc
source/lac/chunk_sparsity_pattern.cc
source/lac/compressed_set_sparsity_pattern.cc [deleted file]
source/lac/compressed_sparsity_pattern.cc [deleted file]
source/lac/constraint_matrix.cc
source/lac/dynamic_sparsity_pattern.cc [moved from source/lac/compressed_simple_sparsity_pattern.cc with 80% similarity]
source/lac/petsc_parallel_block_sparse_matrix.cc
source/lac/petsc_parallel_sparse_matrix.cc
source/lac/petsc_sparse_matrix.cc
source/lac/sparsity_pattern.cc
source/lac/sparsity_tools.cc
source/lac/trilinos_block_sparse_matrix.cc
source/lac/trilinos_sparse_matrix.cc
source/lac/trilinos_sparsity_pattern.cc
tests/lac/sparsity_pattern_common.h

index 7e97a5eea3338507dd7a07f1a1bbe410d5df0ed1..e655291ad161979f0681899beb922d68a04e444f 100644 (file)
@@ -80,15 +80,11 @@ FEVALUES_BASES := { FEValuesBase<deal_II_dimension>;
                    FEFaceValuesBase<deal_II_dimension> }
 
 SPARSITY_PATTERNS := { SparsityPattern;
-                       CompressedSparsityPattern;
-                       CompressedSetSparsityPattern;
-                       CompressedSimpleSparsityPattern;
+                       DynamicSparsityPattern;
                        @DEAL_II_EXPAND_TRILINOS_SPARSITY_PATTERN@;
 
                        BlockSparsityPattern;
-                       BlockCompressedSparsityPattern;
-                       BlockCompressedSetSparsityPattern;
-                       BlockCompressedSimpleSparsityPattern;
+                       BlockDynamicSparsityPattern;
                        @DEAL_II_EXPAND_TRILINOS_BLOCK_SPARSITY_PATTERN@; }
 
 DIMENSIONS := { 1; 2; 3 }
index c8f6eb556c437c810af5e623c10d6df07d491b5b..7ade2ed7fbbffcae3a0a8fcbb602e09a2cd3d640 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2006 - 2014 by the deal.II authors
+// Copyright (C) 2006 - 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// See documentation of BlockCompressedSparsityPattern for documentation of this example
+// See documentation of BlockDynamicSparsityPattern for documentation of this example
 
 #include <deal.II/lac/block_sparsity_pattern.h>
 #include <deal.II/lac/constraint_matrix.h>
@@ -55,7 +55,7 @@ int main()
   std::vector<unsigned int> dofs_per_block(fe.n_blocks());
   DoFTools::count_dofs_per_block(dof, dofs_per_block);
 
-  BlockCompressedSparsityPattern c_sparsity(fe.n_blocks(), fe.n_blocks());
+  BlockDynamicSparsityPattern c_sparsity(fe.n_blocks(), fe.n_blocks());
   for (unsigned int i=0; i<fe.n_blocks(); ++i)
     for (unsigned int j=0; j<fe.n_blocks(); ++j)
       c_sparsity.block(i,j).reinit(dofs_per_block[i],dofs_per_block[j]);
index e65df26313337022bdd80bd4dabf01fd25a96c03..aaadf896b9da02407e08ea46e58c1e6caf6fc729 100644 (file)
@@ -44,9 +44,9 @@
 #include <deal.II/numerics/matrix_tools.h>
 
 // Just this one is new: it declares a class
-// <code>CompressedSparsityPattern</code>, which we will use and explain
+// <code>DynamicSparsityPattern</code>, which we will use and explain
 // further down below.
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 
 // We will make use of the std::find algorithm of the C++ standard library, so
 // we have to include the following file for its declaration:
@@ -202,7 +202,7 @@ namespace Step11
     //
     // Since this can be so difficult that no reasonable answer can be given
     // that allows allocation of only a reasonable amount of memory, there is
-    // a class <code>CompressedSparsityPattern</code>, that can help us out
+    // a class <code>DynamicSparsityPattern</code>, that can help us out
     // here. It does not require that we know in advance how many entries rows
     // could have, but allows just about any length. It is thus significantly
     // more flexible in case you do not have good estimates of row lengths,
@@ -215,15 +215,15 @@ namespace Step11
     // pattern due to the differential operator, then condense it with the
     // constraints object which adds those positions in the sparsity pattern
     // that are required for the elimination of the constraint.
-    CompressedSparsityPattern csp (dof_handler.n_dofs(),
-                                   dof_handler.n_dofs());
+    DynamicSparsityPattern csp (dof_handler.n_dofs(),
+                                dof_handler.n_dofs());
     DoFTools::make_sparsity_pattern (dof_handler, csp);
     mean_value_constraints.condense (csp);
 
     // Finally, once we have the full pattern, we can initialize an object of
     // type <code>SparsityPattern</code> from it and in turn initialize the
     // matrix with it. Note that this is actually necessary, since the
-    // <code>CompressedSparsityPattern</code> is so inefficient compared to
+    // <code>DynamicSparsityPattern</code> is so inefficient compared to
     // the <code>SparsityPattern</code> class due to the more flexible data
     // structures it has to use, that we can impossibly base the sparse matrix
     // class on it, but rather need an object of type
index 6c79a26074a2a664082caa548b3023388c7f8988..5800662b3cb290fdfa54712dfe9131873b75cedc 100644 (file)
@@ -23,7 +23,7 @@
 #include <deal.II/base/quadrature_lib.h>
 #include <deal.II/base/function.h>
 #include <deal.II/lac/vector.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/sparse_matrix.h>
 #include <deal.II/grid/tria.h>
 #include <deal.II/grid/grid_generator.h>
@@ -215,14 +215,14 @@ namespace Step12
     dof_handler.distribute_dofs (fe);
 
     // We start by generating the sparsity pattern. To this end, we first fill
-    // an intermediate object of type CompressedSparsityPattern with the
+    // an intermediate object of type DynamicSparsityPattern with the
     // couplings appearing in the system. After building the pattern, this
     // object is copied to <code>sparsity_pattern</code> and can be discarded.
 
     // To build the sparsity pattern for DG discretizations, we can call the
     // function analogue to DoFTools::make_sparsity_pattern, which is called
     // DoFTools::make_flux_sparsity_pattern:
-    CompressedSparsityPattern c_sparsity(dof_handler.n_dofs());
+    DynamicSparsityPattern c_sparsity(dof_handler.n_dofs());
     DoFTools::make_flux_sparsity_pattern (dof_handler, c_sparsity);
     sparsity_pattern.copy_from(c_sparsity);
 
index d9de739577d5e49f5e6032bbe66b0068186b67dd..7bc173e742da900267f7a787c7b8aa559f3ea103 100644 (file)
@@ -32,6 +32,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/lac/constraint_matrix.h>
@@ -1035,20 +1036,20 @@ namespace Step13
       Threads::Task<> side_task(std_cxx11::bind(mhnc_p,std_cxx11::cref(dof_handler),
                                                 std_cxx11::ref(hanging_node_constraints)));
 
-      sparsity_pattern.reinit (dof_handler.n_dofs(),
-                               dof_handler.n_dofs(),
-                               dof_handler.max_couplings_between_dofs());
-      DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
+      DynamicSparsityPattern csp(dof_handler.n_dofs(), dof_handler.n_dofs());
+      DoFTools::make_sparsity_pattern (dof_handler, csp);
+
+
 
       // Wait for the side task to be done before going further
       side_task.join();
 
       hanging_node_constraints.close ();
-      hanging_node_constraints.condense (sparsity_pattern);
+      hanging_node_constraints.condense (csp);
+      sparsity_pattern.copy_from(csp);
+
 
-      // Finally, close the sparsity pattern, initialize the matrix, and set
-      // the right hand side vector to the right size.
-      sparsity_pattern.compress();
+      // Finally initialize the matrix and right hand side vector
       matrix.reinit (sparsity_pattern);
       rhs.reinit (dof_handler.n_dofs());
     }
index 42d98fbcb74ba3fe561c07623826e89ef9ac8233..061fa9ee0cd98569a6932e04ef48b2a4bf91f378 100644 (file)
@@ -27,6 +27,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/lac/constraint_matrix.h>
@@ -709,22 +710,22 @@ namespace Step14
                       ConstraintMatrix &)
         = &DoFTools::make_hanging_node_constraints;
 
-      Threads::Task<> side_task
-        = Threads::new_task (mhnc_p,
-                             dof_handler,
-                             hanging_node_constraints);
+      // Start a side task then continue on the main thread
+      Threads::Task<> side_task(std_cxx11::bind(mhnc_p,std_cxx11::cref(dof_handler),
+                                                std_cxx11::ref(hanging_node_constraints)));
 
-      sparsity_pattern.reinit (dof_handler.n_dofs(),
-                               dof_handler.n_dofs(),
-                               dof_handler.max_couplings_between_dofs());
-      DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
+      DynamicSparsityPattern csp(dof_handler.n_dofs(), dof_handler.n_dofs());
+      DoFTools::make_sparsity_pattern (dof_handler, csp);
 
+
+
+      // Wait for the side task to be done before going further
       side_task.join();
 
       hanging_node_constraints.close ();
-      hanging_node_constraints.condense (sparsity_pattern);
+      hanging_node_constraints.condense (csp);
+      sparsity_pattern.copy_from(csp);
 
-      sparsity_pattern.compress();
       matrix.reinit (sparsity_pattern);
       rhs.reinit (dof_handler.n_dofs());
     }
index 7682ae4aff27e7e12e382244d219d64a4069db46..691d7bc761131acd31501b5b681593676a7e0bd4 100644 (file)
@@ -30,7 +30,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/lac/constraint_matrix.h>
@@ -208,7 +208,7 @@ namespace Step15
     newton_update.reinit (dof_handler.n_dofs());
     system_rhs.reinit (dof_handler.n_dofs());
 
-    CompressedSparsityPattern c_sparsity(dof_handler.n_dofs());
+    DynamicSparsityPattern c_sparsity(dof_handler.n_dofs());
     DoFTools::make_sparsity_pattern (dof_handler, c_sparsity);
 
     hanging_node_constraints.condense (c_sparsity);
index f879864ea5381886710a98982bb565ab2464b093..4c4edee95d3921165753f15a7de5e0c312bf06df 100644 (file)
@@ -277,10 +277,8 @@ namespace Step16
                   ? ")" : ", ");
     deallog << std::endl;
 
-    sparsity_pattern.reinit (dof_handler.n_dofs(),
-                             dof_handler.n_dofs(),
-                             dof_handler.max_couplings_between_dofs());
-    DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
+    DynamicSparsityPattern csp(dof_handler.n_dofs(), dof_handler.n_dofs());
+    DoFTools::make_sparsity_pattern (dof_handler, csp);
 
     solution.reinit (dof_handler.n_dofs());
     system_rhs.reinit (dof_handler.n_dofs());
@@ -298,8 +296,8 @@ namespace Step16
                                               constraints);
     constraints.close ();
     hanging_node_constraints.close ();
-    constraints.condense (sparsity_pattern);
-    sparsity_pattern.compress();
+    constraints.condense (csp);
+    sparsity_pattern.copy_from (csp);
     system_matrix.reinit (sparsity_pattern);
 
     // The multigrid constraints have to be initialized. They need to know
@@ -345,9 +343,8 @@ namespace Step16
     // matrices.
     for (unsigned int level=0; level<n_levels; ++level)
       {
-        CompressedSparsityPattern csp;
-        csp.reinit(dof_handler.n_dofs(level),
-                   dof_handler.n_dofs(level));
+        DynamicSparsityPattern csp (dof_handler.n_dofs(level),
+                                    dof_handler.n_dofs(level));
         MGTools::make_sparsity_pattern(dof_handler, csp, level);
 
         mg_sparsity_patterns[level].copy_from (csp);
index 727e9de7aa19ad74fdc4673628def73f55fb5869..a86bf9b4ecc8bd6095e149f552dcaeaf73dcbeb8 100644 (file)
@@ -29,7 +29,7 @@
 #include <deal.II/base/utilities.h>
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_parallel_sparse_matrix.h>
@@ -966,11 +966,11 @@ namespace Step18
     // going to work with, and make sure that the condensation of hanging node
     // constraints add the necessary additional entries in the sparsity
     // pattern:
-    CompressedSparsityPattern sparsity_pattern (dof_handler.n_dofs(),
-                                                dof_handler.n_dofs());
+    DynamicSparsityPattern sparsity_pattern (dof_handler.n_dofs(),
+                                             dof_handler.n_dofs());
     DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
     hanging_node_constraints.condense (sparsity_pattern);
-    // Note that we have used the <code>CompressedSparsityPattern</code> class
+    // Note that we have used the <code>DynamicSparsityPattern</code> class
     // here that was already introduced in step-11, rather than the
     // <code>SparsityPattern</code> class that we have used in all other
     // cases. The reason for this is that for the latter class to work we have
@@ -989,7 +989,7 @@ namespace Step18
     // too much memory can lead to out-of-memory situations.
     //
     // In order to avoid this, we resort to the
-    // <code>CompressedSparsityPattern</code> class that is slower but does
+    // <code>DynamicSparsityPattern</code> class that is slower but does
     // not require any up-front estimate on the number of nonzero entries per
     // row. It therefore only ever allocates as much memory as it needs at any
     // given time, and we can build it even for large 3d problems.
index 9036bbbe355c7ce0db0b1cb6fb7c3cdcd8c4e00c..9702a20f35eea73534b0e54f8e4ea9359964d1db 100644 (file)
@@ -48,7 +48,7 @@
 #include <deal.II/lac/sparse_matrix.h>
 // We will also need to use an intermediate sparsity pattern structure, which
 // is found in this file:
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 
 // We will want to use a special algorithm to renumber degrees of freedom. It
 // is declared here:
@@ -195,15 +195,15 @@ void distribute_dofs (DoFHandler<2> &dof_handler)
   // number, leading to a lot of wasted memory, sometimes too much for the
   // machine used, even if the unused memory can be released immediately after
   // computing the sparsity pattern. In order to avoid this, we use an
-  // intermediate object of type CompressedSparsityPattern that uses a
+  // intermediate object of type DynamicSparsityPattern that uses a
   // different %internal data structure and that we can later copy into the
   // SparsityPattern object without much overhead. (Some more information on
   // these data structures can be found in the @ref Sparsity module.) In order
   // to initialize this intermediate data structure, we have to give it the
   // size of the matrix, which in our case will be square with as many rows
   // and columns as there are degrees of freedom on the grid:
-  CompressedSparsityPattern compressed_sparsity_pattern(dof_handler.n_dofs(),
-                                                        dof_handler.n_dofs());
+  DynamicSparsityPattern compressed_sparsity_pattern(dof_handler.n_dofs(),
+                                                     dof_handler.n_dofs());
 
   // We then fill this object with the places where nonzero elements will be
   // located given the present numbering of degrees of freedom:
@@ -211,7 +211,7 @@ void distribute_dofs (DoFHandler<2> &dof_handler)
 
   // Now we are ready to create the actual sparsity pattern that we could
   // later use for our matrix. It will just contain the data already assembled
-  // in the CompressedSparsityPattern.
+  // in the DynamicSparsityPattern.
   SparsityPattern sparsity_pattern;
   sparsity_pattern.copy_from (compressed_sparsity_pattern);
 
@@ -265,8 +265,8 @@ void renumber_dofs (DoFHandler<2> &dof_handler)
 {
   DoFRenumbering::Cuthill_McKee (dof_handler);
 
-  CompressedSparsityPattern compressed_sparsity_pattern(dof_handler.n_dofs(),
-                                                        dof_handler.n_dofs());
+  DynamicSparsityPattern compressed_sparsity_pattern(dof_handler.n_dofs(),
+                                                     dof_handler.n_dofs());
   DoFTools::make_sparsity_pattern (dof_handler, compressed_sparsity_pattern);
 
   SparsityPattern sparsity_pattern;
index 08a76fa2a6178bf988f6dab9ba9de7b531203928..81e9c73a971e3948e780c83361a10d8f0b4c602f 100644 (file)
@@ -358,14 +358,14 @@ namespace Step20
     // The next task is to allocate a sparsity pattern for the matrix that we
     // will create. We use a compressed sparsity pattern like in the previous
     // steps, but as <code>system_matrix</code> is a block matrix we use the
-    // class <code>BlockCompressedSparsityPattern</code> instead of just
-    // <code>CompressedSparsityPattern</code>. This block sparsity pattern has
+    // class <code>BlockDynamicSparsityPattern</code> instead of just
+    // <code>DynamicSparsityPattern</code>. This block sparsity pattern has
     // four blocks in a $2 \times 2$ pattern. The blocks' sizes depend on
     // <code>n_u</code> and <code>n_p</code>, which hold the number of velocity
     // and pressure variables. In the second step we have to instruct the block
     // system to update its knowledge about the sizes of the blocks it manages;
     // this happens with the <code>c_sparsity.collect_sizes ()</code> call.
-    BlockCompressedSparsityPattern c_sparsity(2, 2);
+    BlockDynamicSparsityPattern c_sparsity(2, 2);
     c_sparsity.block(0, 0).reinit (n_u, n_u);
     c_sparsity.block(1, 0).reinit (n_p, n_u);
     c_sparsity.block(0, 1).reinit (n_u, n_p);
index ad8097640794db66b7a9047d665677d2d1e67f8c..ce1458b395516ac78a901d2f42569aa95d8963e8 100644 (file)
@@ -521,32 +521,11 @@ namespace Step22
     // BlockSparsityPattern. This is entirely analogous to what we already did
     // in step-11 and step-18.
     //
-    // There is one snag again here, though: it turns out that using the
-    // CompressedSparsityPattern (or the block version
-    // BlockCompressedSparsityPattern we would use here) has a bottleneck that
-    // makes the algorithm to build the sparsity pattern be quadratic in the
-    // number of degrees of freedom. This doesn't become noticeable until we
-    // get well into the range of several 100,000 degrees of freedom, but
-    // eventually dominates the setup of the linear system when we get to more
-    // than a million degrees of freedom. This is due to the data structures
-    // used in the CompressedSparsityPattern class, nothing that can easily be
-    // changed. Fortunately, there is an easy solution: the
-    // CompressedSimpleSparsityPattern class (and its block variant
-    // BlockCompressedSimpleSparsityPattern) has exactly the same interface,
-    // uses a different %internal data structure and is linear in the number
-    // of degrees of freedom and therefore much more efficient for large
-    // problems. As another alternative, we could also have chosen the class
-    // BlockCompressedSetSparsityPattern that uses yet another strategy for
-    // %internal memory management. Though, that class turns out to be more
-    // memory-demanding than BlockCompressedSimpleSparsityPattern for this
-    // example.
-    //
-    // Consequently, this is the class that we will use for our intermediate
-    // sparsity representation. All this is done inside a new scope, which
+    // All this is done inside a new scope, which
     // means that the memory of <code>csp</code> will be released once the
     // information has been copied to <code>sparsity_pattern</code>.
     {
-      BlockCompressedSimpleSparsityPattern csp (2,2);
+      BlockDynamicSparsityPattern csp (2,2);
 
       csp.block(0,0).reinit (n_u, n_u);
       csp.block(1,0).reinit (n_p, n_u);
index d588b12be601f6c52aca0917767d53ddb20bf66d..429c565d7883ffe839c2223a410acc6cb2314a4e 100644 (file)
@@ -29,6 +29,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/lac/constraint_matrix.h>
@@ -332,11 +333,9 @@ namespace Step23
               << std::endl
               << std::endl;
 
-    sparsity_pattern.reinit (dof_handler.n_dofs(),
-                             dof_handler.n_dofs(),
-                             dof_handler.max_couplings_between_dofs());
-    DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
-    sparsity_pattern.compress();
+    DynamicSparsityPattern csp(dof_handler.n_dofs(), dof_handler.n_dofs());
+    DoFTools::make_sparsity_pattern (dof_handler, csp);
+    sparsity_pattern.copy_from (csp);
 
     // Then comes a block where we have to initialize the 3 matrices we need
     // in the course of the program: the mass matrix, the Laplace matrix, and
index 3302780e16f2df1e9dedb666bba5718bc9782474..700aeeaaa7c27a900f8420be263d71936d900eb6 100644 (file)
@@ -29,6 +29,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/lac/constraint_matrix.h>
@@ -289,11 +290,9 @@ namespace Step24
               << std::endl
               << std::endl;
 
-    sparsity_pattern.reinit (dof_handler.n_dofs(),
-                             dof_handler.n_dofs(),
-                             dof_handler.max_couplings_between_dofs());
-    DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
-    sparsity_pattern.compress();
+    DynamicSparsityPattern csp(dof_handler.n_dofs(), dof_handler.n_dofs());
+    DoFTools::make_sparsity_pattern (dof_handler, csp);
+    sparsity_pattern.copy_from (csp);
 
     system_matrix.reinit (sparsity_pattern);
     mass_matrix.reinit (sparsity_pattern);
index a5cd3e39242d4a6471fca9b7299e46d7615854f4..d182d7dd3aba1aa23ea4f36e6652dc5e1a94772a 100644 (file)
@@ -33,6 +33,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/lac/constraint_matrix.h>
@@ -306,11 +307,9 @@ namespace Step25
               << dof_handler.n_dofs()
               << std::endl;
 
-    sparsity_pattern.reinit (dof_handler.n_dofs(),
-                             dof_handler.n_dofs(),
-                             dof_handler.max_couplings_between_dofs());
-    DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
-    sparsity_pattern.compress ();
+    DynamicSparsityPattern csp(dof_handler.n_dofs(), dof_handler.n_dofs());
+    DoFTools::make_sparsity_pattern (dof_handler, csp);
+    sparsity_pattern.copy_from (csp);
 
     system_matrix.reinit  (sparsity_pattern);
     mass_matrix.reinit    (sparsity_pattern);
index 2ba5c0193263e4b9bd9681ef85503efad6db2345..6d6781f28cf20101ca03f9b90a3061ea2a0938f6 100644 (file)
@@ -26,7 +26,7 @@
 #include <deal.II/base/logstream.h>
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/sparse_matrix.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
@@ -249,7 +249,7 @@ namespace Step26
                                              constraints);
     constraints.close();
 
-    CompressedSparsityPattern c_sparsity(dof_handler.n_dofs());
+    DynamicSparsityPattern c_sparsity(dof_handler.n_dofs());
     DoFTools::make_sparsity_pattern(dof_handler,
                                     c_sparsity,
                                     constraints,
index fa4491bd80fa98416a4c412e0aed4fe6dadb4adb..c1ed5552ab1008ca75b056a136b012c8b46411bc 100644 (file)
 #include <deal.II/numerics/error_estimator.h>
 
 // These are the new files we need. The first one provides an alternative to
-// the usual SparsityPattern class and the CompressedSparsityPattern class
+// the usual SparsityPattern class and the DynamicSparsityPattern class
 // already discussed in step-11 and step-18. The last two provide <i>hp</i>
 // versions of the DoFHandler and FEValues classes as described in the
 // introduction of this program.
-#include <deal.II/lac/compressed_set_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/hp/dof_handler.h>
 #include <deal.II/hp/fe_values.h>
 
@@ -212,8 +212,8 @@ namespace Step27
                                               constraints);
     constraints.close ();
 
-    CompressedSetSparsityPattern csp (dof_handler.n_dofs(),
-                                      dof_handler.n_dofs());
+    DynamicSparsityPattern csp (dof_handler.n_dofs(),
+                                dof_handler.n_dofs());
     DoFTools::make_sparsity_pattern (dof_handler, csp, constraints, false);
     sparsity_pattern.copy_from (csp);
 
index f457ad3fd58df390c001ce5b79a9d90072d1e0fe..296fd7dbd4911742b4074e58bea8e4f554f4e46a 100644 (file)
@@ -31,6 +31,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/sparse_matrix.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
@@ -592,11 +593,10 @@ namespace Step28
 
     system_matrix.clear ();
 
-    sparsity_pattern.reinit (n_dofs, n_dofs,
-                             dof_handler.max_couplings_between_dofs());
-    DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
-    hanging_node_constraints.condense (sparsity_pattern);
-    sparsity_pattern.compress ();
+    DynamicSparsityPattern csp(n_dofs, n_dofs);
+    DoFTools::make_sparsity_pattern (dof_handler, csp);
+    hanging_node_constraints.condense (csp);
+    sparsity_pattern.copy_from (csp);
 
     system_matrix.reinit (sparsity_pattern);
 
index 99e88375a07956076d9cbe53bbc8e790b7dd47e9..f18b368ae5015bd1a69bceaf87379441476e275f 100644 (file)
@@ -30,6 +30,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 
 #include <deal.II/grid/tria.h>
 #include <deal.II/grid/grid_generator.h>
@@ -537,12 +538,9 @@ namespace Step29
 
     dof_handler.distribute_dofs (fe);
 
-    sparsity_pattern.reinit (dof_handler.n_dofs(),
-                             dof_handler.n_dofs(),
-                             dof_handler.max_couplings_between_dofs());
-
-    DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
-    sparsity_pattern.compress();
+    DynamicSparsityPattern csp(dof_handler.n_dofs(), dof_handler.n_dofs());
+    DoFTools::make_sparsity_pattern (dof_handler, csp);
+    sparsity_pattern.copy_from (csp);
 
     system_matrix.reinit (sparsity_pattern);
     system_rhs.reinit (dof_handler.n_dofs());
index bc7faaa162394c2456992b4816d773dabcda619a..60ca98c3b3f476c6f80c9dcc1213165521cf53b3 100644 (file)
@@ -66,7 +66,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 
@@ -208,7 +208,7 @@ void Step3::setup_system ()
   // first creating a temporary structure, tagging those entries that might be
   // nonzero, and then copying the data over to the SparsityPattern object
   // that can then be used by the system matrix.
-  CompressedSparsityPattern c_sparsity(dof_handler.n_dofs());
+  DynamicSparsityPattern c_sparsity(dof_handler.n_dofs());
   DoFTools::make_sparsity_pattern (dof_handler, c_sparsity);
   sparsity_pattern.copy_from(c_sparsity);
 
index e20e382f60cbb185dc14932cebb75a8a5fbe4bd3..7f311fd9cd63eb61f814ec9361a1c30f8a32cfc2 100644 (file)
@@ -919,16 +919,13 @@ namespace Step31
     // The next step is to create the sparsity pattern for the Stokes and
     // temperature system matrices as well as the preconditioner matrix from
     // which we build the Stokes preconditioner. As in step-22, we choose to
-    // create the pattern not as in the first few tutorial programs, but by
-    // using the blocked version of CompressedSimpleSparsityPattern.  The
-    // reason for doing this is mainly memory, that is, the SparsityPattern
-    // class would consume too much memory when used in three spatial
-    // dimensions as we intend to do for this program.
+    // create the pattern by
+    // using the blocked version of DynamicSparsityPattern.
     //
     // So, we first release the memory stored in the matrices, then set up an
-    // object of type BlockCompressedSimpleSparsityPattern consisting of
+    // object of type BlockDynamicSparsityPattern consisting of
     // $2\times 2$ blocks (for the Stokes system matrix and preconditioner) or
-    // CompressedSimpleSparsityPattern (for the temperature part). We then
+    // DynamicSparsityPattern (for the temperature part). We then
     // fill these objects with the nonzero pattern, taking into account that
     // for the Stokes system matrix, there are no entries in the
     // pressure-pressure block (but all velocity vector components couple with
@@ -961,7 +958,7 @@ namespace Step31
     {
       stokes_matrix.clear ();
 
-      BlockCompressedSimpleSparsityPattern csp (2,2);
+      BlockDynamicSparsityPattern csp (2,2);
 
       csp.block(0,0).reinit (n_u, n_u);
       csp.block(0,1).reinit (n_u, n_p);
@@ -990,7 +987,7 @@ namespace Step31
       Mp_preconditioner.reset ();
       stokes_preconditioner_matrix.clear ();
 
-      BlockCompressedSimpleSparsityPattern csp (2,2);
+      BlockDynamicSparsityPattern csp (2,2);
 
       csp.block(0,0).reinit (n_u, n_u);
       csp.block(0,1).reinit (n_u, n_p);
@@ -1030,7 +1027,7 @@ namespace Step31
       temperature_stiffness_matrix.clear ();
       temperature_matrix.clear ();
 
-      CompressedSimpleSparsityPattern csp (n_T, n_T);
+      DynamicSparsityPattern csp (n_T, n_T);
       DoFTools::make_sparsity_pattern (temperature_dof_handler, csp,
                                        temperature_constraints, false);
 
index e669208c469819ba2f0dc2851b55e929986dffd0..021550ffcef9976a5229a4482522623aab0ccc7d 100644 (file)
@@ -1803,7 +1803,7 @@ namespace Step32
   // is that the matrices we want to set up are distributed across multiple
   // processors. Since we still want to build up the sparsity pattern first
   // for efficiency reasons, we could continue to build the <i>entire</i>
-  // sparsity pattern as a BlockCompressedSimpleSparsityPattern, as we did in
+  // sparsity pattern as a BlockDynamicSparsityPattern, as we did in
   // step-31. However, that would be inefficient: every processor would build
   // the same sparsity pattern, but only initialize a small part of the matrix
   // using it. It also violates the principle that every processor should only
index 3e466a14ecb56dcdb1c136b8bc440f4edd1a0bad..b46fc60fdab1ad43c9284dbfe6e153a7abd89f6e 100644 (file)
@@ -31,7 +31,7 @@
 #include <deal.II/base/std_cxx11/array.h>
 
 #include <deal.II/lac/vector.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 
 #include <deal.II/grid/tria.h>
 #include <deal.II/grid/grid_generator.h>
@@ -1401,8 +1401,8 @@ namespace Step33
   template <int dim>
   void ConservationLaw<dim>::setup_system ()
   {
-    CompressedSparsityPattern sparsity_pattern (dof_handler.n_dofs(),
-                                                dof_handler.n_dofs());
+    DynamicSparsityPattern sparsity_pattern (dof_handler.n_dofs(),
+                                             dof_handler.n_dofs());
     DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
 
     system_matrix.reinit (sparsity_pattern);
index b472a8f1dc3a465e3b292868dbf883b06bfab69d..8742441d21be99c07c3257fce1abd8216c468441 100644 (file)
@@ -36,6 +36,7 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/sparse_matrix.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/lac/solver_gmres.h>
@@ -789,13 +790,11 @@ namespace Step35
   void
   NavierStokesProjection<dim>::initialize_velocity_matrices()
   {
-    sparsity_pattern_velocity.reinit (dof_handler_velocity.n_dofs(),
-                                      dof_handler_velocity.n_dofs(),
-                                      dof_handler_velocity.max_couplings_between_dofs());
-    DoFTools::make_sparsity_pattern (dof_handler_velocity,
-                                     sparsity_pattern_velocity);
-    sparsity_pattern_velocity.compress();
-
+    {
+      DynamicSparsityPattern csp(dof_handler_velocity.n_dofs(), dof_handler_velocity.n_dofs());
+      DoFTools::make_sparsity_pattern (dof_handler_velocity, csp);
+      sparsity_pattern_velocity.copy_from (csp);
+    }
     vel_Laplace_plus_Mass.reinit (sparsity_pattern_velocity);
     for (unsigned int d=0; d<dim; ++d)
       vel_it_matrix[d].reinit (sparsity_pattern_velocity);
@@ -817,11 +816,11 @@ namespace Step35
   void
   NavierStokesProjection<dim>::initialize_pressure_matrices()
   {
-    sparsity_pattern_pressure.reinit (dof_handler_pressure.n_dofs(), dof_handler_pressure.n_dofs(),
-                                      dof_handler_pressure.max_couplings_between_dofs());
-    DoFTools::make_sparsity_pattern (dof_handler_pressure, sparsity_pattern_pressure);
-
-    sparsity_pattern_pressure.compress();
+    {
+      DynamicSparsityPattern csp(dof_handler_pressure.n_dofs(), dof_handler_pressure.n_dofs());
+      DoFTools::make_sparsity_pattern (dof_handler_pressure, csp);
+      sparsity_pattern_pressure.copy_from (csp);
+    }
 
     pres_Laplace.reinit (sparsity_pattern_pressure);
     pres_iterative.reinit (sparsity_pattern_pressure);
@@ -847,13 +846,11 @@ namespace Step35
   void
   NavierStokesProjection<dim>::initialize_gradient_operator()
   {
-    sparsity_pattern_pres_vel.reinit (dof_handler_velocity.n_dofs(),
-                                      dof_handler_pressure.n_dofs(),
-                                      dof_handler_velocity.max_couplings_between_dofs());
-    DoFTools::make_sparsity_pattern (dof_handler_velocity,
-                                     dof_handler_pressure,
-                                     sparsity_pattern_pres_vel);
-    sparsity_pattern_pres_vel.compress();
+    {
+      DynamicSparsityPattern csp(dof_handler_velocity.n_dofs(), dof_handler_pressure.n_dofs());
+      DoFTools::make_sparsity_pattern (dof_handler_velocity, dof_handler_pressure, csp);
+      sparsity_pattern_pres_vel.copy_from (csp);
+    }
 
     InitGradPerTaskData per_task_data (0, fe_velocity.dofs_per_cell,
                                        fe_pressure.dofs_per_cell);
index 9b047190a1c199a39cc79cc437a65ced98338fe8..6cc02f2e9fb20f98151843a59d7441ae85ba4ee5 100644 (file)
@@ -151,7 +151,7 @@ namespace Step36
   // sure that we do not need to re-allocate memory and free the one used
   // previously. One way to do that would be to use code like this:
   // @code
-  //   CompressedSimpleSparsityPattern
+  //   DynamicSparsityPattern
   //      csp (dof_handler.n_dofs(),
   //           dof_handler.n_dofs());
   //   DoFTools::make_sparsity_pattern (dof_handler, csp);
index acc6275fd81ac1c4d86497d304b524527620edf9..0bc5e4435ae46e65c8cf1d0fcec735c0cb6c44b9 100644 (file)
@@ -36,7 +36,7 @@
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/lac/sparse_matrix.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/dofs/dof_handler.h>
 #include <deal.II/dofs/dof_accessor.h>
 #include <deal.II/dofs/dof_tools.h>
@@ -341,7 +341,7 @@ namespace Step38
               << " degrees of freedom."
               << std::endl;
 
-    CompressedSparsityPattern csp (dof_handler.n_dofs(), dof_handler.n_dofs());
+    DynamicSparsityPattern csp (dof_handler.n_dofs(), dof_handler.n_dofs());
     DoFTools::make_sparsity_pattern (dof_handler, csp);
     sparsity_pattern.copy_from (csp);
 
index cf340a9ab517126adc3f2d4465d0513efaf7fa59..03d5aa97dc9fe6d4e86ca8c24e5043efcf55e0ed 100644 (file)
@@ -22,7 +22,7 @@
 // turn will include the necessary files for SparsityPattern and Vector
 // classes.
 #include <deal.II/lac/sparse_matrix.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/lac/precondition_block.h>
@@ -500,9 +500,9 @@ namespace Step39
 
     // Next, we set up the sparsity pattern for the global matrix. Since we do
     // not know the row sizes in advance, we first fill a temporary
-    // CompressedSparsityPattern object and copy it to the regular
+    // DynamicSparsityPattern object and copy it to the regular
     // SparsityPattern once it is complete.
-    CompressedSparsityPattern c_sparsity(n_dofs);
+    DynamicSparsityPattern c_sparsity(n_dofs);
     DoFTools::make_flux_sparsity_pattern(dof_handler, c_sparsity);
     sparsity.copy_from(c_sparsity);
     matrix.reinit(sparsity);
@@ -529,7 +529,7 @@ namespace Step39
       {
         // These are roughly the same lines as above for the global matrix,
         // now for each level.
-        CompressedSparsityPattern c_sparsity(dof_handler.n_dofs(level));
+        DynamicSparsityPattern c_sparsity(dof_handler.n_dofs(level));
         MGTools::make_flux_sparsity_pattern(dof_handler, c_sparsity, level);
         mg_sparsity[level].copy_from(c_sparsity);
         mg_matrix[level].reinit(mg_sparsity[level]);
@@ -540,7 +540,7 @@ namespace Step39
         // object on level 0.
         if (level>0)
           {
-            CompressedSparsityPattern ci_sparsity;
+            DynamicSparsityPattern ci_sparsity;
             ci_sparsity.reinit(dof_handler.n_dofs(level-1), dof_handler.n_dofs(level));
             MGTools::make_flux_sparsity_pattern_edge(dof_handler, ci_sparsity, level);
             mg_sparsity_dg_interface[level].copy_from(ci_sparsity);
index b26f2d045dac8e6365eb5f3ee948dbc5ac8eaf03..a8f06c66cf9aa28d7ecf95991331d85c7eb21e16 100644 (file)
@@ -38,7 +38,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 
@@ -271,7 +271,7 @@ void Step4<dim>::setup_system ()
             << dof_handler.n_dofs()
             << std::endl;
 
-  CompressedSparsityPattern c_sparsity(dof_handler.n_dofs());
+  DynamicSparsityPattern c_sparsity(dof_handler.n_dofs());
   DoFTools::make_sparsity_pattern (dof_handler, c_sparsity);
   sparsity_pattern.copy_from(c_sparsity);
 
index afc0da2d75d3381a1bc539322514862b4c8c78e8..9dda199522bf5e7f8577529c6690552b21c1ab3f 100644 (file)
@@ -45,7 +45,7 @@ namespace LA
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/constraint_matrix.h>
-#include <deal.II/lac/compressed_simple_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 
 #include <deal.II/lac/petsc_parallel_sparse_matrix.h>
 #include <deal.II/lac/petsc_parallel_vector.h>
@@ -295,7 +295,7 @@ namespace Step40
 
     // The last part of this function deals with initializing the matrix with
     // accompanying sparsity pattern. As in previous tutorial programs, we use
-    // the CompressedSimpleSparsityPattern as an intermediate with which we
+    // the DynamicSparsityPattern as an intermediate with which we
     // then initialize the PETSc matrix. To do so we have to tell the sparsity
     // pattern its size but as above there is no way the resulting object will
     // be able to store even a single pointer for each global degree of
@@ -315,7 +315,7 @@ namespace Step40
     // entries that will exist in that part of the finite element matrix that
     // it will own. The final step is to initialize the matrix with the
     // sparsity pattern.
-    CompressedSimpleSparsityPattern csp (locally_relevant_dofs);
+    DynamicSparsityPattern csp (locally_relevant_dofs);
 
     DoFTools::make_sparsity_pattern (dof_handler, csp,
                                      constraints, false);
index a95c310f186364c7177442877d6c5b58637c5e05..b2211d7e424016635cc04f20e8da974e54b1d56c 100644 (file)
@@ -31,7 +31,7 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <deal.II/lac/trilinos_vector.h>
@@ -246,7 +246,7 @@ namespace Step41
                                               constraints);
     constraints.close ();
 
-    CompressedSparsityPattern c_sparsity(dof_handler.n_dofs());
+    DynamicSparsityPattern c_sparsity(dof_handler.n_dofs());
     DoFTools::make_sparsity_pattern (dof_handler,
                                      c_sparsity,
                                      constraints,
index c534b2c9c6cb10047705cb7372c76306b0761bcf..1199c985ad11a12a823fb03656926a3dfc308ba3 100644 (file)
@@ -677,13 +677,10 @@ namespace Step43
   // various blocks. This information is then used to create the sparsity
   // pattern for the Darcy and saturation system matrices as well as the
   // preconditioner matrix from which we build the Darcy preconditioner. As in
-  // step-31, we choose to create the pattern not as in the first few tutorial
-  // programs, but by using the blocked version of
-  // CompressedSimpleSparsityPattern. The reason for doing this is mainly
-  // memory, that is, the SparsityPattern class would consume too much memory
-  // when used in three spatial dimensions as we intend to do for this
-  // program. So, for this, we follow the same way as step-31 did and we don't
-  // have to repeat descriptions again for the rest of the member function.
+  // step-31, we choose to create the pattern using the blocked version of
+  // DynamicSparsityPattern. So, for this, we follow the same way as step-31
+  // did and we don't have to repeat descriptions again for the rest of the
+  // member function.
   template <int dim>
   void TwoPhaseFlowProblem<dim>::setup_dofs ()
   {
@@ -739,7 +736,7 @@ namespace Step43
     {
       darcy_matrix.clear ();
 
-      BlockCompressedSimpleSparsityPattern csp (2,2);
+      BlockDynamicSparsityPattern csp (2,2);
 
       csp.block(0,0).reinit (n_u, n_u);
       csp.block(0,1).reinit (n_u, n_p);
@@ -769,7 +766,7 @@ namespace Step43
       Mp_preconditioner.reset ();
       darcy_preconditioner_matrix.clear ();
 
-      BlockCompressedSimpleSparsityPattern csp (2,2);
+      BlockDynamicSparsityPattern csp (2,2);
 
       csp.block(0,0).reinit (n_u, n_u);
       csp.block(0,1).reinit (n_u, n_p);
@@ -796,7 +793,7 @@ namespace Step43
     {
       saturation_matrix.clear ();
 
-      CompressedSimpleSparsityPattern csp (n_s, n_s);
+      DynamicSparsityPattern csp (n_s, n_s);
 
       DoFTools::make_sparsity_pattern (saturation_dof_handler, csp,
                                        saturation_constraints, false);
index b72df4657fc65600a85d8ff884ee4884376d6e9c..e59bd88b5354ee63e36963d7d3e9e24ecbd7ee7f 100644 (file)
@@ -50,7 +50,7 @@
 
 #include <deal.II/lac/block_sparse_matrix.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/precondition_selector.h>
 #include <deal.II/lac/solver_cg.h>
@@ -1582,7 +1582,7 @@ namespace Step44
       const types::global_dof_index n_dofs_p = dofs_per_block[p_dof];
       const types::global_dof_index n_dofs_J = dofs_per_block[J_dof];
 
-      BlockCompressedSimpleSparsityPattern csp(n_blocks, n_blocks);
+      BlockDynamicSparsityPattern csp(n_blocks, n_blocks);
 
       csp.block(u_dof, u_dof).reinit(n_dofs_u, n_dofs_u);
       csp.block(u_dof, p_dof).reinit(n_dofs_u, n_dofs_p);
index d0b80883fa51e008caf5b00e33fb8d7dcd468291..72a1e1d67b9e32d5e57ccc02b599154d4b096456 100644 (file)
@@ -32,7 +32,7 @@
 #include <deal.II/lac/solver_control.h>
 #include <deal.II/lac/sparse_matrix.h>
 #include <deal.II/lac/sparsity_pattern.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -180,8 +180,8 @@ namespace Step45
     // Then we create the sparsity pattern and the system matrix and
     // initialize the solution and right-hand side vectors. This is again as
     // in step-3 or step-6, for example:
-    CompressedSparsityPattern c_sparsity_pattern (dof_handler.n_dofs(),
-                                                  dof_handler.n_dofs());
+    DynamicSparsityPattern c_sparsity_pattern (dof_handler.n_dofs(),
+                                               dof_handler.n_dofs());
     DoFTools::make_sparsity_pattern (dof_handler,
                                      c_sparsity_pattern,
                                      constraints,
index 252a0e7aa07e0f5fcff4224a89b006e43d3cd29c..a0e46f92717c498961350b6ce232301dcae3217e 100644 (file)
@@ -460,8 +460,8 @@ namespace Step46
     // extensively in the introduction, and use it to initialize the matrix;
     // then also set vectors to their correct sizes:
     {
-      CompressedSimpleSparsityPattern csp (dof_handler.n_dofs(),
-                                           dof_handler.n_dofs());
+      DynamicSparsityPattern csp (dof_handler.n_dofs(),
+                                  dof_handler.n_dofs());
 
       Table<2,DoFTools::Coupling> cell_coupling (fe_collection.n_components(),
                                                  fe_collection.n_components());
index ea3cdbbe15b1b3112c069ba7bc1a6e9a88317bc7..3e30d75d920c2ab8eefd6e5496381ca4e8f1dd56 100644 (file)
@@ -24,7 +24,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/grid/tria.h>
@@ -259,7 +259,7 @@ namespace Step47
     constraints.close();
 
 
-    CompressedSparsityPattern c_sparsity(dof_handler.n_dofs());
+    DynamicSparsityPattern c_sparsity(dof_handler.n_dofs());
     DoFTools::make_sparsity_pattern (dof_handler, c_sparsity);
 
     constraints.condense (c_sparsity);
index f51f193b76cdb877e8ce7701f8fad308244bac0b..a808db5c55f5a17156020013f7d643d653bbf839 100644 (file)
@@ -28,7 +28,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/grid/tria.h>
@@ -270,7 +270,7 @@ void Step5<dim>::setup_system ()
             << dof_handler.n_dofs()
             << std::endl;
 
-  CompressedSparsityPattern c_sparsity(dof_handler.n_dofs());
+  DynamicSparsityPattern c_sparsity(dof_handler.n_dofs());
   DoFTools::make_sparsity_pattern (dof_handler, c_sparsity);
   sparsity_pattern.copy_from(c_sparsity);
 
index 05a0d79ae7604858d988752ddf78dee9f9674a03..ab4729587715b16b7cae2e02158b76d97b1104f7 100644 (file)
@@ -371,7 +371,7 @@ namespace Step50
     constraints.close ();
     hanging_node_constraints.close ();
 
-    CompressedSimpleSparsityPattern csp(mg_dof_handler.n_dofs(), mg_dof_handler.n_dofs());
+    DynamicSparsityPattern csp(mg_dof_handler.n_dofs(), mg_dof_handler.n_dofs());
     DoFTools::make_sparsity_pattern (mg_dof_handler, csp, constraints);
     system_matrix.reinit (mg_dof_handler.locally_owned_dofs(), csp, MPI_COMM_WORLD, true);
 
@@ -434,9 +434,8 @@ namespace Step50
     // matrices.
     for (unsigned int level=0; level<n_levels; ++level)
       {
-        CompressedSparsityPattern csp;
-        csp.reinit(mg_dof_handler.n_dofs(level),
-                   mg_dof_handler.n_dofs(level));
+        DynamicSparsityPattern csp(mg_dof_handler.n_dofs(level),
+                                   mg_dof_handler.n_dofs(level));
         MGTools::make_sparsity_pattern(mg_dof_handler, csp, level);
 
         mg_matrices[level].reinit(mg_dof_handler.locally_owned_mg_dofs(level),
index 646d49a1e5ec88ee1c9c9dadb88511424a91c02f..0f512514f234fa24a74283eeacc79e3c07346eb1 100644 (file)
@@ -31,7 +31,7 @@
 #include <deal.II/base/convergence_table.h>
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
-#include <deal.II/lac/compressed_simple_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_bicgstab.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/grid/tria.h>
@@ -470,7 +470,7 @@ namespace Step51
     // to the number of dofs on a face, when copying this into the final
     // sparsity pattern.
     {
-      CompressedSimpleSparsityPattern csp (dof_handler.n_dofs());
+      DynamicSparsityPattern csp (dof_handler.n_dofs());
       DoFTools::make_sparsity_pattern (dof_handler, csp,
                                        constraints, false);
       sparsity_pattern.copy_from(csp, fe.dofs_per_face);
index dfef5db0df8772ef67cd127ed70bb43906e91794..81ee24d6b7bf3f447c77c429ef54874e803d383e 100644 (file)
@@ -169,7 +169,7 @@ namespace Step52
     VectorTools::interpolate_boundary_values(dof_handler,1,ZeroFunction<2>(),constraint_matrix);
     constraint_matrix.close();
 
-    CompressedSparsityPattern c_sparsity(dof_handler.n_dofs());
+    DynamicSparsityPattern c_sparsity(dof_handler.n_dofs());
     DoFTools::make_sparsity_pattern(dof_handler,c_sparsity,constraint_matrix);
     sparsity_pattern.copy_from(c_sparsity);
 
index 73ca65448cfbbfbf8d6504f90808d842209a3596..ac0fc3be25a41e36bafe93c1544438ea6b07534d 100644 (file)
@@ -28,7 +28,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/grid/tria.h>
@@ -284,9 +284,7 @@ Step6<dim>::~Step6 ()
 // sparsity pattern, and initializing the solution and right hand side
 // vectors. Note that the sparsity pattern will have significantly more
 // entries per row now, since there are now 9 degrees of freedom per cell, not
-// only four, that can couple with each other. The
-// <code>dof_Handler.max_couplings_between_dofs()</code> call will take care
-// of this, however:
+// only four, that can couple with each other.
 template <int dim>
 void Step6<dim>::setup_system ()
 {
@@ -346,7 +344,7 @@ void Step6<dim>::setup_system ()
   // constraints after assembling, we would have to pass <code>true</code>
   // instead because then we would first write into these locations only to
   // later set them to zero again during condensation.
-  CompressedSparsityPattern c_sparsity(dof_handler.n_dofs());
+  DynamicSparsityPattern c_sparsity(dof_handler.n_dofs());
   DoFTools::make_sparsity_pattern(dof_handler,
                                   c_sparsity,
                                   constraints,
index d60488a5d08581308f3487b5a3c6d8f23411869f..7442ff11c0a1b1ae4425851f4cf63a2f865cab06 100644 (file)
@@ -28,6 +28,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/lac/constraint_matrix.h>
@@ -530,12 +531,10 @@ namespace Step7
                                              hanging_node_constraints);
     hanging_node_constraints.close ();
 
-    sparsity_pattern.reinit (dof_handler.n_dofs(),
-                             dof_handler.n_dofs(),
-                             dof_handler.max_couplings_between_dofs());
-    DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
-    hanging_node_constraints.condense (sparsity_pattern);
-    sparsity_pattern.compress();
+    DynamicSparsityPattern csp (dof_handler.n_dofs(), dof_handler.n_dofs());
+    DoFTools::make_sparsity_pattern (dof_handler, csp);
+    hanging_node_constraints.condense (csp);
+    sparsity_pattern.copy_from (csp);
 
     system_matrix.reinit (sparsity_pattern);
 
index 74b01ee845eb1e2b3851488eff60f5b0d71b45a7..a72fbda2a8e2bc5b3a415c29cd5c7ae600ba7dd2 100644 (file)
@@ -28,6 +28,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/lac/constraint_matrix.h>
@@ -340,14 +341,13 @@ namespace Step8
     DoFTools::make_hanging_node_constraints (dof_handler,
                                              hanging_node_constraints);
     hanging_node_constraints.close ();
-    sparsity_pattern.reinit (dof_handler.n_dofs(),
-                             dof_handler.n_dofs(),
-                             dof_handler.max_couplings_between_dofs());
-    DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
 
-    hanging_node_constraints.condense (sparsity_pattern);
-
-    sparsity_pattern.compress();
+    DynamicSparsityPattern csp(dof_handler.n_dofs(), dof_handler.n_dofs());
+    DoFTools::make_sparsity_pattern(dof_handler,
+                                    csp,
+                                    hanging_node_constraints,
+                                    /*keep_constrained_dofs = */ true);
+    sparsity_pattern.copy_from (csp);
 
     system_matrix.reinit (sparsity_pattern);
 
index 092e9f9c4335e403ae610391a9f16a8ced3f2d99..b1610e40496652386836837632d9b448d811914c 100644 (file)
@@ -26,6 +26,7 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/solver_bicgstab.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/lac/constraint_matrix.h>
@@ -547,20 +548,17 @@ namespace Step9
   void AdvectionProblem<dim>::setup_system ()
   {
     dof_handler.distribute_dofs (fe);
-
     hanging_node_constraints.clear ();
     DoFTools::make_hanging_node_constraints (dof_handler,
                                              hanging_node_constraints);
     hanging_node_constraints.close ();
 
-    sparsity_pattern.reinit (dof_handler.n_dofs(),
-                             dof_handler.n_dofs(),
-                             dof_handler.max_couplings_between_dofs());
-    DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
-
-    hanging_node_constraints.condense (sparsity_pattern);
-
-    sparsity_pattern.compress();
+    DynamicSparsityPattern csp(dof_handler.n_dofs(), dof_handler.n_dofs());
+    DoFTools::make_sparsity_pattern(dof_handler,
+                                    csp,
+                                    hanging_node_constraints,
+                                    /*keep_constrained_dofs = */ true);
+    sparsity_pattern.copy_from (csp);
 
     system_matrix.reinit (sparsity_pattern);
 
index 27c6477f08efead78c46b23b2610540e1f48ff71..e9a6b34e56f21b32f19fbcb8aa8197c120178ecd 100644 (file)
@@ -34,9 +34,7 @@ DEAL_II_NAMESPACE_OPEN
 
 template <typename number> class BlockSparseMatrix;
 class BlockSparsityPattern;
-class BlockCompressedSparsityPattern;
-class BlockCompressedSimpleSparsityPattern;
-class BlockCompressedSetSparsityPattern;
+class BlockDynamicSparsityPattern;
 #ifdef DEAL_II_WITH_TRILINOS
 namespace TrilinosWrappers
 {
@@ -443,31 +441,12 @@ public:
   std::size_t memory_consumption () const;
 
   /**
-   * Copy data from an object of type BlockCompressedSparsityPattern, i.e.
+   * Copy data from an object of type BlockDynamicSparsityPattern, i.e.
    * resize this object to the size of the given argument, and copy over the
    * contents of each of the subobjects. Previous content of this object is
    * lost.
    */
-  void copy_from (const BlockCompressedSparsityPattern &csp);
-
-  /**
-   * Copy data from an object of type BlockCompressedSetSparsityPattern, i.e.
-   * resize this object to the size of the given argument, and copy over the
-   * contents of each of the subobjects. Previous content of this object is
-   * lost.
-   */
-  void copy_from (const BlockCompressedSetSparsityPattern &csp);
-
-  /**
-   * Copy data from an object of type BlockCompressedSimpleSparsityPattern,
-   * i.e. resize this object to the size of the given argument, and copy over
-   * the contents of each of the subobjects. Previous content of this object
-   * is lost.
-   */
-  void copy_from (const BlockCompressedSimpleSparsityPattern &csp);
-
-
-
+  void copy_from (const BlockDynamicSparsityPattern &csp);
 };
 
 
@@ -484,14 +463,9 @@ public:
  * This class is an example of the "dynamic" type of
  * @ref Sparsity.
  *
- * <b>Note:</b> There are several, exchangeable variations of this class, see
- * @ref Sparsity,
- * section 'Dynamic block sparsity patterns' for more information.
- *
- *
  * <h3>Example</h3>
  *
- * Usage of this class is very similar to CompressedSparsityPattern, but since
+ * Usage of this class is very similar to DynamicSparsityPattern, but since
  * the use of block indices causes some additional complications, we give a
  * short example.
  *
@@ -503,7 +477,7 @@ public:
  *
  * @skipline dofs_per_block @until count
  *
- * Now, we are ready to set up the BlockCompressedSparsityPattern.
+ * Now, we are ready to set up the BlockDynamicSparsityPattern.
  *
  * @until collect
  *
@@ -517,85 +491,8 @@ public:
  *
  * @author Wolfgang Bangerth, 2000, 2001, Guido Kanschat, 2006, 2007
  */
-class BlockCompressedSparsityPattern : public BlockSparsityPatternBase<CompressedSparsityPattern>
-{
-public:
-
-  /**
-   * Initialize the matrix empty, that is with no memory allocated. This is
-   * useful if you want such objects as member variables in other classes. You
-   * can make the structure usable by calling the reinit() function.
-   */
-  BlockCompressedSparsityPattern ();
 
-  /**
-   * Initialize the matrix with the given number of block rows and columns.
-   * The blocks themselves are still empty, and you have to call
-   * collect_sizes() after you assign them sizes.
-   */
-  BlockCompressedSparsityPattern (const size_type n_rows,
-                                  const size_type n_columns);
-
-  /**
-   * Initialize the pattern with two BlockIndices for the block structures of
-   * matrix rows and columns. This function is equivalent to calling the
-   * previous constructor with the length of the two index vector and then
-   * entering the index values.
-   */
-  BlockCompressedSparsityPattern (const std::vector<size_type> &row_block_sizes,
-                                  const std::vector<size_type> &col_block_sizes);
-
-  /**
-   * Initialize the pattern with two BlockIndices for the block structures of
-   * matrix rows and columns.
-   */
-  BlockCompressedSparsityPattern (const BlockIndices &row_indices,
-                                  const BlockIndices &col_indices);
-
-  /**
-   * Resize the matrix to a tensor product of matrices with dimensions defined
-   * by the arguments.
-   *
-   * The matrix will have as many block rows and columns as there are entries
-   * in the two arguments. The block at position (<i>i,j</i>) will have the
-   * dimensions <tt>row_block_sizes[i]</tt> times <tt>col_block_sizes[j]</tt>.
-   */
-  void reinit (const std::vector<size_type> &row_block_sizes,
-               const std::vector<size_type> &col_block_sizes);
-
-  /**
-   * Resize the matrix to a tensor product of matrices with dimensions defined
-   * by the arguments. The two BlockIndices objects must be initialized and
-   * the sparsity pattern will have the same block structure afterwards.
-   */
-  void reinit (const BlockIndices &row_indices, const BlockIndices &col_indices);
-
-  /**
-   * Allow the use of the reinit functions of the base class as well.
-   */
-  using BlockSparsityPatternBase<CompressedSparsityPattern>::reinit;
-};
-
-
-
-/**
- * This class extends the base class to implement an array of compressed
- * sparsity patterns that can be used to initialize objects of type
- * BlockSparsityPattern. It is used in the same way as the
- * BlockCompressedSparsityPattern except that it builds upon the
- * CompressedSetSparsityPattern instead of the CompressedSparsityPattern. See
- * the documentation of the BlockCompressedSparsityPattern for examples.
- *
- * This class is an example of the "dynamic" type of
- * @ref Sparsity.
- *
- * @note There are several, exchangeable variations of this class, see
- * @ref Sparsity,
- * section 'Dynamic block sparsity patterns' for more information.
- *
- * @author Wolfgang Bangerth, 2007
- */
-class BlockCompressedSetSparsityPattern : public BlockSparsityPatternBase<CompressedSetSparsityPattern>
+class BlockDynamicSparsityPattern : public BlockSparsityPatternBase<DynamicSparsityPattern>
 {
 public:
 
@@ -604,15 +501,15 @@ public:
    * useful if you want such objects as member variables in other classes. You
    * can make the structure usable by calling the reinit() function.
    */
-  BlockCompressedSetSparsityPattern ();
+  BlockDynamicSparsityPattern ();
 
   /**
    * Initialize the matrix with the given number of block rows and columns.
    * The blocks themselves are still empty, and you have to call
    * collect_sizes() after you assign them sizes.
    */
-  BlockCompressedSetSparsityPattern (const size_type n_rows,
-                                     const size_type n_columns);
+  BlockDynamicSparsityPattern (const size_type n_rows,
+                               const size_type n_columns);
 
   /**
    * Initialize the pattern with two BlockIndices for the block structures of
@@ -620,90 +517,8 @@ public:
    * previous constructor with the length of the two index vector and then
    * entering the index values.
    */
-  BlockCompressedSetSparsityPattern (const std::vector<size_type> &row_block_sizes,
-                                     const std::vector<size_type> &col_block_sizes);
-
-  /**
-   * Initialize the pattern with two BlockIndices for the block structures of
-   * matrix rows and columns.
-   */
-  BlockCompressedSetSparsityPattern (const BlockIndices &row_indices,
-                                     const BlockIndices &col_indices);
-
-  /**
-   * Resize the matrix to a tensor product of matrices with dimensions defined
-   * by the arguments.
-   *
-   * The matrix will have as many block rows and columns as there are entries
-   * in the two arguments. The block at position (<i>i,j</i>) will have the
-   * dimensions <tt>row_block_sizes[i]</tt> times <tt>col_block_sizes[j]</tt>.
-   */
-  void reinit (const std::vector<size_type> &row_block_sizes,
-               const std::vector<size_type> &col_block_sizes);
-
-  /**
-   * Resize the matrix to a tensor product of matrices with dimensions defined
-   * by the arguments. The two BlockIndices objects must be initialized and
-   * the sparsity pattern will have the same block structure afterwards.
-   */
-  void reinit (const BlockIndices &row_indices, const BlockIndices &col_indices);
-
-  /**
-   * Allow the use of the reinit functions of the base class as well.
-   */
-  using BlockSparsityPatternBase<CompressedSetSparsityPattern>::reinit;
-};
-
-
-
-
-
-/**
- * This class extends the base class to implement an array of compressed
- * sparsity patterns that can be used to initialize objects of type
- * BlockSparsityPattern. It is used in the same way as the
- * BlockCompressedSparsityPattern except that it builds upon the
- * CompressedSimpleSparsityPattern instead of the CompressedSparsityPattern.
- * See the documentation of the BlockCompressedSparsityPattern for examples.
- *
- * This class is an example of the "dynamic" type of
- * @ref Sparsity.
- *
- * @note There are several, exchangeable variations of this class, see
- * @ref Sparsity,
- * section 'Dynamic block sparsity patterns' for more information.
- *
- * This class is used in step-22 and step-31.
- *
- * @author Timo Heister, 2008
- */
-class BlockCompressedSimpleSparsityPattern : public BlockSparsityPatternBase<CompressedSimpleSparsityPattern>
-{
-public:
-
-  /**
-   * Initialize the matrix empty, that is with no memory allocated. This is
-   * useful if you want such objects as member variables in other classes. You
-   * can make the structure usable by calling the reinit() function.
-   */
-  BlockCompressedSimpleSparsityPattern ();
-
-  /**
-   * Initialize the matrix with the given number of block rows and columns.
-   * The blocks themselves are still empty, and you have to call
-   * collect_sizes() after you assign them sizes.
-   */
-  BlockCompressedSimpleSparsityPattern (const size_type n_rows,
-                                        const size_type n_columns);
-
-  /**
-   * Initialize the pattern with two BlockIndices for the block structures of
-   * matrix rows and columns. This function is equivalent to calling the
-   * previous constructor with the length of the two index vector and then
-   * entering the index values.
-   */
-  BlockCompressedSimpleSparsityPattern (const std::vector<size_type> &row_block_sizes,
-                                        const std::vector<size_type> &col_block_sizes);
+  BlockDynamicSparsityPattern (const std::vector<size_type> &row_block_sizes,
+                               const std::vector<size_type> &col_block_sizes);
 
   /**
    * Initialize the pattern with symmetric blocks. The number of IndexSets in
@@ -713,7 +528,7 @@ public:
    * which is useful for distributed memory parallel computations and usually
    * corresponds to the locally owned DoFs.
    */
-  BlockCompressedSimpleSparsityPattern (const std::vector<IndexSet> &partitioning);
+  BlockDynamicSparsityPattern (const std::vector<IndexSet> &partitioning);
 
   /**
    * Resize the pattern to a tensor product of matrices with dimensions
@@ -742,9 +557,24 @@ public:
   /**
    * Allow the use of the reinit functions of the base class as well.
    */
-  using BlockSparsityPatternBase<CompressedSimpleSparsityPattern>::reinit;
+  using BlockSparsityPatternBase<DynamicSparsityPattern>::reinit;
 };
 
+/**
+ * @deprecated Use  BlockDynamicSparsityPattern instead.
+ */
+typedef BlockDynamicSparsityPattern BlockCompressedSparsityPattern DEAL_II_DEPRECATED;
+
+/**
+ * @deprecated Use  BlockDynamicSparsityPattern instead.
+ */
+typedef BlockDynamicSparsityPattern BlockCompressedSetSparsityPattern DEAL_II_DEPRECATED;
+
+/**
+ * @deprecated Use  BlockDynamicSparsityPattern instead.
+ */
+typedef BlockDynamicSparsityPattern BlockCompressedSimpleSparsityPattern DEAL_II_DEPRECATED;
+
 
 
 
@@ -1108,9 +938,9 @@ BlockSparsityPatternBase<SparsityPatternBase>::n_block_rows () const
 
 
 inline
-BlockCompressedSimpleSparsityPattern::size_type
-BlockCompressedSimpleSparsityPattern::column_number (const size_type row,
-                                                     const unsigned int index) const
+BlockDynamicSparsityPattern::size_type
+BlockDynamicSparsityPattern::column_number (const size_type row,
+                                            const unsigned int index) const
 {
   // .first= ith block, .second = jth row in that block
   const std::pair<size_type ,size_type >
index 379fd7248026d5a005fd3e84e93aeb8e7a2adafd..7a7aa12ce13e4ce6358f9624631cc0d7e5e765f1 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2001 - 2014 by the deal.II authors
+// Copyright (C) 2001 - 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
 
 
 #include <deal.II/base/config.h>
-#include <deal.II/base/subscriptor.h>
-#include <deal.II/lac/exceptions.h>
-
-#include <vector>
-#include <algorithm>
-#include <set>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 
 DEAL_II_NAMESPACE_OPEN
 
-template <typename number> class SparseMatrix;
-
 /*! @addtogroup Sparsity
  *@{
  */
 
-
 /**
- * This class acts as an intermediate form of the SparsityPattern class. From
- * the interface it mostly represents a SparsityPattern object that is kept
- * compressed at all times. However, since the final sparsity pattern is not
- * known while constructing it, keeping the pattern compressed at all times
- * can only be achieved at the expense of either increased memory or run time
- * consumption upon use. The main purpose of this class is to avoid some
- * memory bottlenecks, so we chose to implement it memory conservative, but
- * the chosen data format is too unsuited to be used for actual matrices. It
- * is therefore necessary to first copy the data of this object over to an
- * object of type SparsityPattern before using it in actual matrices.
- *
- * Another viewpoint is that this class does not need up front allocation of a
- * certain amount of memory, but grows as necessary.  An extensive description
- * of sparsity patterns can be found in the documentation of the
- * @ref Sparsity
- * module.
- *
- * This class is an example of the "dynamic" type of
- * @ref Sparsity.
- * It is discussed in the step-27 and
- * @ref step_22 "step-22"
- * tutorial programs.
- *
- * <h3>Interface</h3>
- *
- * Since this class is intended as an intermediate replacement of the
- * SparsityPattern class, it has mostly the same interface, with small changes
- * where necessary. In particular, the add() function, and the functions
- * inquiring properties of the sparsity pattern are the same.
- *
- *
- * <h3>Usage</h3>
- *
- * Use this class as follows:
- * @code
- * CompressedSetSparsityPattern compressed_pattern (dof_handler.n_dofs());
- * DoFTools::make_sparsity_pattern (dof_handler,
- *                                  compressed_pattern);
- * constraints.condense (compressed_pattern);
- *
- * SparsityPattern sp;
- * sp.copy_from (compressed_pattern);
- * @endcode
- *
- * See also step-11 and step-18 for usage patterns of the related
- * CompressedSparsityPattern class, and step-27 of the current class.
- *
- * <h3>Notes</h3>
- *
- * There are several, exchangeable variations of this class, see
- * @ref Sparsity,
- * section '"Dynamic" or "compressed" sparsity patterns' for more information.
- *
- * This class is a variation of the CompressedSparsityPattern class. Instead
- * of using sorted vectors together with a caching algorithm for storing the
- * column indices of nonzero entries, the std::set container is used. This
- * solution might not be the fastest in all situations, but seems to work much
- * better than the CompressedSparsityPattern in the context of hp-adaptivity
- * (see for example step-27), or generally when there are many nonzero entries
- * in each row of a matrix (see
- * @ref step_22 "step-22").
- * On the other hand, a benchmark where nonzero entries were randomly inserted
- * into the sparsity pattern revealed that this class is slower by a factor
- * 4-6 in this situation. Hence, currently the suggestion is to carefully
- * analyze which of the CompressedSparsityPattern classes works best in a
- * certain setting. An algorithm which performs equally well in all situations
- * still has to be found.
- *
- *
- * @author Oliver Kayser-Herold, 2007
+ * @deprecated Use DynamicSparsityPattern instead.
  */
-class CompressedSetSparsityPattern : public Subscriptor
-{
-public:
-  /**
-   * Declare the type for container size.
-   */
-  typedef types::global_dof_index size_type;
-
-  /**
-   * An iterator that can be used to iterate over the elements of a single
-   * row. The result of dereferencing such an iterator is a column index.
-   */
-  typedef std::set<size_type>::const_iterator row_iterator;
-
-
-  /**
-   * Initialize the matrix empty, that is with no memory allocated. This is
-   * useful if you want such objects as member variables in other classes. You
-   * can make the structure usable by calling the reinit() function.
-   */
-  CompressedSetSparsityPattern ();
-
-  /**
-   * Copy constructor. This constructor is only allowed to be called if the
-   * matrix structure to be copied is empty. This is so in order to prevent
-   * involuntary copies of objects for temporaries, which can use large
-   * amounts of computing time.  However, copy constructors are needed if yo
-   * want to use the STL data types on classes like this, e.g. to write such
-   * statements like <tt>v.push_back (CompressedSetSparsityPattern());</tt>,
-   * with @p v a vector of @p CompressedSetSparsityPattern objects.
-   */
-  CompressedSetSparsityPattern (const CompressedSetSparsityPattern &);
-
-  /**
-   * Initialize a rectangular matrix with @p m rows and @p n columns.
-   */
-  CompressedSetSparsityPattern (const size_type m,
-                                const size_type n);
-
-  /**
-   * Initialize a square matrix of dimension @p n.
-   */
-  CompressedSetSparsityPattern (const size_type n);
-
-  /**
-   * Copy operator. For this the same holds as for the copy constructor: it is
-   * declared, defined and fine to be called, but the latter only for empty
-   * objects.
-   */
-  CompressedSetSparsityPattern &operator = (const CompressedSetSparsityPattern &);
-
-  /**
-   * Reallocate memory and set up data structures for a new matrix with @p m
-   * rows and @p n columns, with at most max_entries_per_row() nonzero entries
-   * per row.
-   */
-  void reinit (const size_type m,
-               const size_type n);
-
-  /**
-   * Since this object is kept compressed at all times anway, this function
-   * does nothing, but is declared to make the interface of this class as much
-   * alike as that of the SparsityPattern class.
-   */
-  void compress ();
-
-  /**
-   * Return whether the object is empty. It is empty if no memory is
-   * allocated, which is the same as that both dimensions are zero.
-   */
-  bool empty () const;
-
-  /**
-   * Return the maximum number of entries per row. Note that this number may
-   * change as entries are added.
-   */
-  size_type max_entries_per_row () const;
-
-  /**
-   * Add a nonzero entry to the matrix. If the entry already exists, nothing
-   * bad happens.
-   */
-  void add (const size_type i,
-            const size_type j);
-
-  /**
-   * Add several nonzero entries to the specified row of the matrix. If the
-   * entries already exist, nothing bad happens.
-   */
-  template <typename ForwardIterator>
-  void add_entries (const size_type row,
-                    ForwardIterator begin,
-                    ForwardIterator end,
-                    const bool      indices_are_sorted = false);
-
-  /**
-   * Check if a value at a certain position may be non-zero.
-   */
-  bool exists (const size_type i,
-               const size_type j) const;
-
-  /**
-   * Make the sparsity pattern symmetric by adding the sparsity pattern of the
-   * transpose object.
-   *
-   * This function throws an exception if the sparsity pattern does not
-   * represent a square matrix.
-   */
-  void symmetrize ();
-
-  /**
-   * Print the sparsity of the matrix. The output consists of one line per row
-   * of the format <tt>[i,j1,j2,j3,...]</tt>. <i>i</i> is the row number and
-   * <i>jn</i> are the allocated columns in this row.
-   */
-  void print (std::ostream &out) const;
-
-  /**
-   * Print the sparsity of the matrix in a format that @p gnuplot understands
-   * and which can be used to plot the sparsity pattern in a graphical way.
-   * The format consists of pairs <tt>i j</tt> of nonzero elements, each
-   * representing one entry of this matrix, one per line of the output file.
-   * Indices are counted from zero on, as usual. Since sparsity patterns are
-   * printed in the same way as matrices are displayed, we print the negative
-   * of the column index, which means that the <tt>(0,0)</tt> element is in
-   * the top left rather than in the bottom left corner.
-   *
-   * Print the sparsity pattern in gnuplot by setting the data style to dots
-   * or points and use the @p plot command.
-   */
-  void print_gnuplot (std::ostream &out) const;
-
-  /**
-   * Return number of rows of this matrix, which equals the dimension of the
-   * image space.
-   */
-  size_type n_rows () const;
-
-  /**
-   * Return number of columns of this matrix, which equals the dimension of
-   * the range space.
-   */
-  size_type n_cols () const;
-
-  /**
-   * Number of entries in a specific row.
-   */
-  size_type row_length (const size_type row) const;
-
-  /**
-   * Return an iterator that can loop over all entries in the given row.
-   * Dereferencing the iterator yields a column index.
-   */
-  row_iterator row_begin (const size_type row) const;
-
-  /**
-   * End iterator for the given row.
-   */
-  row_iterator row_end (const size_type row) const;
-
-
-  /**
-   * Compute the bandwidth of the matrix represented by this structure. The
-   * bandwidth is the maximum of $|i-j|$ for which the index pair $(i,j)$
-   * represents a nonzero entry of the matrix.
-   */
-  size_type bandwidth () const;
-
-  /**
-   * Return the number of nonzero elements allocated through this sparsity
-   * pattern.
-   */
-  size_type n_nonzero_elements () const;
-
-  /**
-   * Return whether this object stores only those entries that have been added
-   * explicitly, or if the sparsity pattern contains elements that have been
-   * added through other means (implicitly) while building it. For the current
-   * class, the result is always true.
-   *
-   * This function mainly serves the purpose of describing the current class
-   * in cases where several kinds of sparsity patterns can be passed as
-   * template arguments.
-   */
-  static
-  bool stores_only_added_elements ();
-
-private:
-  /**
-   * Number of rows that this sparsity structure shall represent.
-   */
-  size_type rows;
-
-  /**
-   * Number of columns that this sparsity structure shall represent.
-   */
-  size_type cols;
-
-  /**
-   * For each row of the matrix, store the allocated non-zero entries as a
-   * std::set of column indices. For a discussion of storage schemes see the
-   * CompressedSparsityPattern::Line class.
-   */
-  struct Line
-  {
-    std::set<size_type> entries;
-
-    /**
-     * Constructor.
-     */
-    Line ();
-
-    /**
-     * Add the given column number to this line.
-     */
-    void add (const size_type col_num);
-
-    /**
-     * Add the columns specified by the iterator range to this line.
-     */
-    template <typename ForwardIterator>
-    void add_entries (ForwardIterator begin,
-                      ForwardIterator end);
-  };
-
-
-  /**
-   * Actual data: store for each row the set of nonzero entries.
-   */
-  std::vector<Line> lines;
-};
+typedef DynamicSparsityPattern CompressedSetSparsityPattern DEAL_II_DEPRECATED;
 
 /*@}*/
-/*---------------------- Inline functions -----------------------------------*/
-
-
-inline
-CompressedSetSparsityPattern::Line::Line ()
-{}
-
-
-
-inline
-void
-CompressedSetSparsityPattern::Line::add (const size_type j)
-{
-  entries.insert (j);
-}
-
-
-
-template <typename ForwardIterator>
-inline
-void
-CompressedSetSparsityPattern::Line::add_entries (ForwardIterator begin,
-                                                 ForwardIterator end)
-{
-  entries.insert (begin, end);
-}
-
-
-
-inline
-CompressedSetSparsityPattern::size_type
-CompressedSetSparsityPattern::n_rows () const
-{
-  return rows;
-}
-
-
-
-inline
-CompressedSetSparsityPattern::size_type
-CompressedSetSparsityPattern::n_cols () const
-{
-  return cols;
-}
-
-
-
-inline
-void
-CompressedSetSparsityPattern::add (const size_type i,
-                                   const size_type j)
-{
-  Assert (i<rows, ExcIndexRangeType<size_type>(i, 0, rows));
-  Assert (j<cols, ExcIndexRangeType<size_type>(j, 0, cols));
-
-  lines[i].add (j);
-}
-
-
-
-template <typename ForwardIterator>
-inline
-void
-CompressedSetSparsityPattern::add_entries (const size_type row,
-                                           ForwardIterator begin,
-                                           ForwardIterator end,
-                                           const bool         /*indices_are_sorted*/)
-{
-  Assert (row < rows, ExcIndexRangeType<size_type> (row, 0, rows));
-
-  lines[row].add_entries (begin, end);
-}
-
-
-
-inline
-CompressedSetSparsityPattern::size_type
-CompressedSetSparsityPattern::row_length (const size_type row) const
-{
-  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
-
-  return lines[row].entries.size();
-}
-
-
-
-inline
-CompressedSetSparsityPattern::row_iterator
-CompressedSetSparsityPattern::row_begin (const size_type row) const
-{
-  return (lines[row].entries.begin ());
-}
-
-
-
-inline
-CompressedSetSparsityPattern::row_iterator
-CompressedSetSparsityPattern::row_end (const size_type row) const
-{
-  return (lines[row].entries.end ());
-}
-
-
-
-inline
-bool
-CompressedSetSparsityPattern::stores_only_added_elements ()
-{
-  return true;
-}
-
 
 DEAL_II_NAMESPACE_CLOSE
 
index 222c9339775162f295bd45b0905abe1eb6b09d2a..fb846cf20c5a3d91ca77acede7f51e7ab666c004 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2001 - 2014 by the deal.II authors
+// Copyright (C) 2001 - 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -23,6 +23,8 @@
 #include <deal.II/lac/exceptions.h>
 #include <deal.II/base/index_set.h>
 
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
+
 #include <vector>
 #include <algorithm>
 #include <iostream>
@@ -36,501 +38,12 @@ template <typename number> class SparseMatrix;
  *@{
  */
 
-
 /**
- * This class acts as an intermediate form of the SparsityPattern class. From
- * the interface it mostly represents a SparsityPattern object that is kept
- * compressed at all times. However, since the final sparsity pattern is not
- * known while constructing it, keeping the pattern compressed at all times
- * can only be achieved at the expense of either increased memory or run time
- * consumption upon use. The main purpose of this class is to avoid some
- * memory bottlenecks, so we chose to implement it memory conservative. The
- * chosen data format is too unsuited to be used for actual matrices, though.
- * It is therefore necessary to first copy the data of this object over to an
- * object of type SparsityPattern before using it in actual matrices.
- *
- * Another viewpoint is that this class does not need up front allocation of a
- * certain amount of memory, but grows as necessary.  An extensive description
- * of sparsity patterns can be found in the documentation of the
- * @ref Sparsity
- * module.
- *
- * This class is an example of the "dynamic" type of
- * @ref Sparsity.
- *
- * <h3>Interface</h3>
- *
- * Since this class is intended as an intermediate replacement of the
- * SparsityPattern class, it has mostly the same interface, with small changes
- * where necessary. In particular, the add() function, and the functions
- * inquiring properties of the sparsity pattern are the same.
- *
- *
- * <h3>Usage</h3>
- *
- * Use this class as follows:
- * @code
- * CompressedSimpleSparsityPattern compressed_pattern (dof_handler.n_dofs());
- * DoFTools::make_sparsity_pattern (dof_handler,
- *                                  compressed_pattern);
- * constraints.condense (compressed_pattern);
- *
- * SparsityPattern sp;
- * sp.copy_from (compressed_pattern);
- * @endcode
- *
- *
- * <h3>Notes</h3>
- *
- * There are several, exchangeable variations of this class, see
- * @ref Sparsity,
- * section '"Dynamic" or "compressed" sparsity patterns' for more information.
- *
- * @author Timo Heister, 2008
+ * @deprecated Use DynamicSparsityPattern instead.
  */
-class CompressedSimpleSparsityPattern : public Subscriptor
-{
-public:
-  /**
-   * Declare the type for container size.
-   */
-  typedef types::global_dof_index size_type;
-
-  /**
-   * An iterator that can be used to iterate over the elements of a single
-   * row. The result of dereferencing such an iterator is a column index.
-   */
-  typedef std::vector<size_type>::const_iterator row_iterator;
-
-  /**
-   * Initialize the matrix empty, that is with no memory allocated. This is
-   * useful if you want such objects as member variables in other classes. You
-   * can make the structure usable by calling the reinit() function.
-   */
-  CompressedSimpleSparsityPattern ();
-
-  /**
-   * Copy constructor. This constructor is only allowed to be called if the
-   * matrix structure to be copied is empty. This is so in order to prevent
-   * involuntary copies of objects for temporaries, which can use large
-   * amounts of computing time.  However, copy constructors are needed if you
-   * want to use the STL data types on classes like this, e.g. to write such
-   * statements like <tt>v.push_back (CompressedSparsityPattern());</tt>, with
-   * @p v a vector of @p CompressedSparsityPattern objects.
-   */
-  CompressedSimpleSparsityPattern (const CompressedSimpleSparsityPattern &);
-
-  /**
-   * Initialize a rectangular matrix with @p m rows and @p n columns. The @p
-   * rowset restricts the storage to elements in rows of this set.  Adding
-   * elements outside of this set has no effect. The default argument keeps
-   * all entries.
-   */
-  CompressedSimpleSparsityPattern (const size_type m,
-                                   const size_type n,
-                                   const IndexSet &rowset = IndexSet());
-
-  /**
-   * Create a square SparsityPattern using the index set.
-   */
-  CompressedSimpleSparsityPattern (const IndexSet &indexset);
-
-  /**
-   * Initialize a square matrix of dimension @p n.
-   */
-  CompressedSimpleSparsityPattern (const size_type n);
-
-  /**
-   * Copy operator. For this the same holds as for the copy constructor: it is
-   * declared, defined and fine to be called, but the latter only for empty
-   * objects.
-   */
-  CompressedSimpleSparsityPattern &operator = (const CompressedSimpleSparsityPattern &);
-
-  /**
-   * Reallocate memory and set up data structures for a new matrix with @p m
-   * rows and @p n columns, with at most max_entries_per_row() nonzero entries
-   * per row. The @p rowset restricts the storage to elements in rows of this
-   * set.  Adding elements outside of this set has no effect. The default
-   * argument keeps all entries.
-   */
-  void reinit (const size_type m,
-               const size_type n,
-               const IndexSet &rowset = IndexSet());
-
-  /**
-   * Since this object is kept compressed at all times anway, this function
-   * does nothing, but is declared to make the interface of this class as much
-   * alike as that of the SparsityPattern class.
-   */
-  void compress ();
-
-  /**
-   * Return whether the object is empty. It is empty if no memory is
-   * allocated, which is the same as that both dimensions are zero.
-   */
-  bool empty () const;
-
-  /**
-   * Return the maximum number of entries per row. Note that this number may
-   * change as entries are added.
-   */
-  size_type max_entries_per_row () const;
-
-  /**
-   * Add a nonzero entry to the matrix. If the entry already exists, nothing
-   * bad happens.
-   */
-  void add (const size_type i,
-            const size_type j);
-
-  /**
-   * Add several nonzero entries to the specified row of the matrix. If the
-   * entries already exist, nothing bad happens.
-   */
-  template <typename ForwardIterator>
-  void add_entries (const size_type row,
-                    ForwardIterator begin,
-                    ForwardIterator end,
-                    const bool      indices_are_unique_and_sorted = false);
-
-  /**
-   * Check if a value at a certain position may be non-zero.
-   */
-  bool exists (const size_type i,
-               const size_type j) const;
-
-  /**
-   * Make the sparsity pattern symmetric by adding the sparsity pattern of the
-   * transpose object.
-   *
-   * This function throws an exception if the sparsity pattern does not
-   * represent a square matrix.
-   */
-  void symmetrize ();
-
-  /**
-   * Print the sparsity of the matrix. The output consists of one line per row
-   * of the format <tt>[i,j1,j2,j3,...]</tt>. <i>i</i> is the row number and
-   * <i>jn</i> are the allocated columns in this row.
-   */
-  void print (std::ostream &out) const;
-
-  /**
-   * Print the sparsity of the matrix in a format that @p gnuplot understands
-   * and which can be used to plot the sparsity pattern in a graphical way.
-   * The format consists of pairs <tt>i j</tt> of nonzero elements, each
-   * representing one entry of this matrix, one per line of the output file.
-   * Indices are counted from zero on, as usual. Since sparsity patterns are
-   * printed in the same way as matrices are displayed, we print the negative
-   * of the column index, which means that the <tt>(0,0)</tt> element is in
-   * the top left rather than in the bottom left corner.
-   *
-   * Print the sparsity pattern in gnuplot by setting the data style to dots
-   * or points and use the @p plot command.
-   */
-  void print_gnuplot (std::ostream &out) const;
-
-  /**
-   * Return number of rows of this matrix, which equals the dimension of the
-   * image space.
-   */
-  size_type n_rows () const;
-
-  /**
-   * Return number of columns of this matrix, which equals the dimension of
-   * the range space.
-   */
-  size_type n_cols () const;
-
-  /**
-   * Number of entries in a specific row. This function can only be called if
-   * the given row is a member of the index set of rows that we want to store.
-   */
-  size_type row_length (const size_type row) const;
-
-  /**
-   * Access to column number field.  Return the column number of the @p
-   * indexth entry in @p row.
-   */
-  size_type column_number (const size_type row,
-                           const size_type index) const;
-
-  /**
-   * Return an iterator that can loop over all entries in the given row.
-   * Dereferencing the iterator yields a column index.
-   */
-  row_iterator row_begin (const size_type row) const;
-
-  /**
-   * Returns the end of the current row.
-   */
-  row_iterator row_end (const size_type row) const;
-  /**
-   * Compute the bandwidth of the matrix represented by this structure. The
-   * bandwidth is the maximum of $|i-j|$ for which the index pair $(i,j)$
-   * represents a nonzero entry of the matrix.
-   */
-  size_type bandwidth () const;
-
-  /**
-   * Return the number of nonzero elements allocated through this sparsity
-   * pattern.
-   */
-  size_type n_nonzero_elements () const;
-
-  /**
-   * Return the IndexSet that sets which rows are active on the current
-   * processor. It corresponds to the IndexSet given to this class in the
-   * constructor or in the reinit function.
-   */
-  const IndexSet &row_index_set () const;
-
-  /**
-   * return whether this object stores only those entries that have been added
-   * explicitly, or if the sparsity pattern contains elements that have been
-   * added through other means (implicitly) while building it. For the current
-   * class, the result is always true.
-   *
-   * This function mainly serves the purpose of describing the current class
-   * in cases where several kinds of sparsity patterns can be passed as
-   * template arguments.
-   */
-  static
-  bool stores_only_added_elements ();
-
-  /**
-   * Determine an estimate for the memory consumption (in bytes) of this
-   * object.
-   */
-  size_type memory_consumption () const;
-
-private:
-  /**
-   * Number of rows that this sparsity structure shall represent.
-   */
-  size_type rows;
-
-  /**
-   * Number of columns that this sparsity structure shall represent.
-   */
-  size_type cols;
-
-  /**
-   * A set that contains the valid rows.
-   */
-
-  IndexSet rowset;
-
-
-  /**
-   * Store some data for each row describing which entries of this row are
-   * nonzero. Data is stored sorted in the @p entries std::vector.  The vector
-   * per row is dynamically growing upon insertion doubling its memory each
-   * time.
-   */
-  struct Line
-  {
-  public:
-    /**
-     * Storage for the column indices of this row. This array is always kept
-     * sorted.
-     */
-    std::vector<size_type> entries;
-
-    /**
-     * Constructor.
-     */
-    Line ();
-
-    /**
-     * Add the given column number to this line.
-     */
-    void add (const size_type col_num);
-
-    /**
-     * Add the columns specified by the iterator range to this line.
-     */
-    template <typename ForwardIterator>
-    void add_entries (ForwardIterator begin,
-                      ForwardIterator end,
-                      const bool indices_are_sorted);
-
-    /**
-     * estimates memory consumption.
-     */
-    size_type memory_consumption () const;
-  };
-
-
-  /**
-   * Actual data: store for each row the set of nonzero entries.
-   */
-  std::vector<Line> lines;
-};
+typedef DynamicSparsityPattern CompressedSimpleSparsityPattern DEAL_II_DEPRECATED;
 
 /*@}*/
-/*---------------------- Inline functions -----------------------------------*/
-
-
-inline
-void
-CompressedSimpleSparsityPattern::Line::add (const size_type j)
-{
-  // first check the last element (or if line is still empty)
-  if ( (entries.size()==0) || ( entries.back() < j) )
-    {
-      entries.push_back(j);
-      return;
-    }
-
-  // do a binary search to find the place where to insert:
-  std::vector<size_type>::iterator
-  it = Utilities::lower_bound(entries.begin(),
-                              entries.end(),
-                              j);
-
-  // If this entry is a duplicate, exit immediately
-  if (*it == j)
-    return;
-
-  // Insert at the right place in the vector. Vector grows automatically to
-  // fit elements. Always doubles its size.
-  entries.insert(it, j);
-}
-
-
-
-inline
-CompressedSimpleSparsityPattern::size_type
-CompressedSimpleSparsityPattern::n_rows () const
-{
-  return rows;
-}
-
-
-
-inline
-types::global_dof_index
-CompressedSimpleSparsityPattern::n_cols () const
-{
-  return cols;
-}
-
-
-
-inline
-void
-CompressedSimpleSparsityPattern::add (const size_type i,
-                                      const size_type j)
-{
-  Assert (i<rows, ExcIndexRangeType<size_type>(i, 0, rows));
-  Assert (j<cols, ExcIndexRangeType<size_type>(j, 0, cols));
-
-  if (rowset.size() > 0 && !rowset.is_element(i))
-    return;
-
-  const size_type rowindex =
-    rowset.size()==0 ? i : rowset.index_within_set(i);
-  lines[rowindex].add (j);
-}
-
-
-
-template <typename ForwardIterator>
-inline
-void
-CompressedSimpleSparsityPattern::add_entries (const size_type row,
-                                              ForwardIterator begin,
-                                              ForwardIterator end,
-                                              const bool      indices_are_sorted)
-{
-  Assert (row < rows, ExcIndexRangeType<size_type> (row, 0, rows));
-
-  if (rowset.size() > 0 && !rowset.is_element(row))
-    return;
-
-  const size_type rowindex =
-    rowset.size()==0 ? row : rowset.index_within_set(row);
-  lines[rowindex].add_entries (begin, end, indices_are_sorted);
-}
-
-
-
-inline
-CompressedSimpleSparsityPattern::Line::Line ()
-{}
-
-
-
-inline
-types::global_dof_index
-CompressedSimpleSparsityPattern::row_length (const size_type row) const
-{
-  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
-  if (rowset.size() > 0 && !rowset.is_element(row))
-    return 0;
-
-  const size_type rowindex =
-    rowset.size()==0 ? row : rowset.index_within_set(row);
-  return lines[rowindex].entries.size();
-}
-
-
-
-inline
-types::global_dof_index
-CompressedSimpleSparsityPattern::column_number (const size_type row,
-                                                const size_type index) const
-{
-  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
-  Assert( rowset.size() == 0 || rowset.is_element(row), ExcInternalError());
-
-  const size_type local_row = rowset.size() ? rowset.index_within_set(row) : row;
-  Assert (index < lines[local_row].entries.size(),
-          ExcIndexRangeType<size_type> (index, 0, lines[local_row].entries.size()));
-  return lines[local_row].entries[index];
-}
-
-
-
-inline
-CompressedSimpleSparsityPattern::row_iterator
-CompressedSimpleSparsityPattern::row_begin (const size_type row) const
-{
-  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
-  const size_type local_row = rowset.size() ? rowset.index_within_set(row) : row;
-  return lines[local_row].entries.begin();
-}
-
-
-
-inline
-CompressedSimpleSparsityPattern::row_iterator
-CompressedSimpleSparsityPattern::row_end (const size_type row) const
-{
-  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
-  const size_type local_row = rowset.size() ? rowset.index_within_set(row) : row;
-  return lines[local_row].entries.end();
-}
-
-
-
-inline
-const IndexSet &
-CompressedSimpleSparsityPattern::row_index_set () const
-{
-  return rowset;
-}
-
-
-
-inline
-bool
-CompressedSimpleSparsityPattern::stores_only_added_elements ()
-{
-  return true;
-}
 
 
 DEAL_II_NAMESPACE_CLOSE
index b4024a7d29d5cb426afeba4378a9437cdc532bb0..b98d4c0d42f1a239607193bcd9d90615ee688332 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2001 - 2014 by the deal.II authors
+// Copyright (C) 2001 - 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
 
 
 #include <deal.II/base/config.h>
-#include <deal.II/base/subscriptor.h>
-#include <deal.II/lac/exceptions.h>
-
-#include <vector>
-#include <algorithm>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 
 DEAL_II_NAMESPACE_OPEN
 
-template <typename number> class SparseMatrix;
-
-
-//  TODO[WB]: Unify implementation with the CompressedSetSparsityPattern
-//  since really all that's different is the Line structure in the two
-//  classes. We should have a templatized base class that simply gets the
-//  particular Line structure from a derived class.
-
 /*! @addtogroup Sparsity
  *@{
  */
 
-
 /**
- * This class acts as an intermediate form of the SparsityPattern class. From
- * the interface it mostly represents a SparsityPattern object that is kept
- * compressed at all times. However, since the final sparsity pattern is not
- * known while constructing it, keeping the pattern compressed at all times
- * can only be achieved at the expense of either increased memory or run time
- * consumption upon use. The main purpose of this class is to avoid some
- * memory bottlenecks, so we chose to implement it memory conservative, but
- * the chosen data format is too unsuited to be used for actual matrices. It
- * is therefore necessary to first copy the data of this object over to an
- * object of type SparsityPattern before using it in actual matrices.
- *
- * Another viewpoint is that this class does not need up front allocation of a
- * certain amount of memory, but grows as necessary.  An extensive description
- * of sparsity patterns can be found in the documentation of the
- * @ref Sparsity
- * module.
- *
- * This class is an example of the "dynamic" type of
- * @ref Sparsity.
- *
- * <h3>Interface</h3>
- *
- * Since this class is intended as an intermediate replacement of the
- * SparsityPattern class, it has mostly the same interface, with small changes
- * where necessary. In particular, the add() function, and the functions
- * inquiring properties of the sparsity pattern are the same.
- *
- *
- * <h3>Usage</h3>
- *
- * Use this class as follows:
- * @code
- * CompressedSparsityPattern compressed_pattern (dof_handler.n_dofs());
- * DoFTools::make_sparsity_pattern (dof_handler,
- *                                  compressed_pattern);
- * constraints.condense (compressed_pattern);
- *
- * SparsityPattern sp;
- * sp.copy_from (compressed_pattern);
- * @endcode
- *
- * See also step-11 and step-18 for usage patterns.
- *
- * <h3>Notes</h3>
- *
- * There are several, exchangeable variations of this class, see
- * @ref Sparsity,
- * section '"Dynamic" or "compressed" sparsity patterns' for more information.
- *
- * @author Wolfgang Bangerth, 2001
+ * @deprecated Use DynamicSparsityPattern instead.
  */
-class CompressedSparsityPattern : public Subscriptor
-{
-public:
-  /**
-   * Declare the type for container size.
-   */
-  typedef types::global_dof_index size_type;
-
-  /**
-   * An iterator that can be used to iterate over the elements of a single
-   * row. The result of dereferencing such an iterator is a column index.
-   */
-  typedef std::vector<size_type>::const_iterator row_iterator;
-
-  /**
-   * Initialize the matrix empty, that is with no memory allocated. This is
-   * useful if you want such objects as member variables in other classes. You
-   * can make the structure usable by calling the reinit() function.
-   */
-  CompressedSparsityPattern ();
-
-  /**
-   * Copy constructor. This constructor is only allowed to be called if the
-   * matrix structure to be copied is empty. This is so in order to prevent
-   * involuntary copies of objects for temporaries, which can use large
-   * amounts of computing time.  However, copy constructors are needed if yo
-   * want to use the STL data types on classes like this, e.g. to write such
-   * statements like <tt>v.push_back (CompressedSparsityPattern());</tt>, with
-   * @p v a vector of @p CompressedSparsityPattern objects.
-   */
-  CompressedSparsityPattern (const CompressedSparsityPattern &);
-
-  /**
-   * Initialize a rectangular matrix with @p m rows and @p n columns.
-   */
-  CompressedSparsityPattern (const size_type m,
-                             const size_type n);
-
-  /**
-   * Initialize a square matrix of dimension @p n.
-   */
-  CompressedSparsityPattern (const size_type n);
-
-  /**
-   * Copy operator. For this the same holds as for the copy constructor: it is
-   * declared, defined and fine to be called, but the latter only for empty
-   * objects.
-   */
-  CompressedSparsityPattern &operator = (const CompressedSparsityPattern &);
-
-  /**
-   * Reallocate memory and set up data structures for a new matrix with @p m
-   * rows and @p n columns, with at most max_entries_per_row() nonzero entries
-   * per row.
-   */
-  void reinit (const size_type m,
-               const size_type n);
-
-  /**
-   * Since this object is kept compressed at all times anway, this function
-   * does nothing, but is declared to make the interface of this class as much
-   * alike as that of the SparsityPattern class.
-   */
-  void compress ();
-
-  /**
-   * Return whether the object is empty. It is empty if no memory is
-   * allocated, which is the same as that both dimensions are zero.
-   */
-  bool empty () const;
-
-  /**
-   * Return the maximum number of entries per row. Note that this number may
-   * change as entries are added.
-   */
-  size_type max_entries_per_row () const;
-
-  /**
-   * Add a nonzero entry to the matrix. If the entry already exists, nothing
-   * bad happens.
-   */
-  void add (const size_type i,
-            const size_type j);
-
-  /**
-   * Add several nonzero entries to the specified row of the matrix. If the
-   * entries already exist, nothing bad happens.
-   */
-  template <typename ForwardIterator>
-  void add_entries (const size_type row,
-                    ForwardIterator begin,
-                    ForwardIterator end,
-                    const bool      indices_are_unique_and_sorted = false);
-
-  /**
-   * Check if a value at a certain position may be non-zero.
-   */
-  bool exists (const size_type i,
-               const size_type j) const;
-
-  /**
-   * Make the sparsity pattern symmetric by adding the sparsity pattern of the
-   * transpose object.
-   *
-   * This function throws an exception if the sparsity pattern does not
-   * represent a square matrix.
-   */
-  void symmetrize ();
-
-  /**
-   * Print the sparsity of the matrix. The output consists of one line per row
-   * of the format <tt>[i,j1,j2,j3,...]</tt>. <i>i</i> is the row number and
-   * <i>jn</i> are the allocated columns in this row.
-   */
-  void print (std::ostream &out) const;
-
-  /**
-   * Print the sparsity of the matrix in a format that @p gnuplot understands
-   * and which can be used to plot the sparsity pattern in a graphical way.
-   * The format consists of pairs <tt>i j</tt> of nonzero elements, each
-   * representing one entry of this matrix, one per line of the output file.
-   * Indices are counted from zero on, as usual. Since sparsity patterns are
-   * printed in the same way as matrices are displayed, we print the negative
-   * of the column index, which means that the <tt>(0,0)</tt> element is in
-   * the top left rather than in the bottom left corner.
-   *
-   * Print the sparsity pattern in gnuplot by setting the data style to dots
-   * or points and use the @p plot command.
-   */
-  void print_gnuplot (std::ostream &out) const;
-
-  /**
-   * Return number of rows of this matrix, which equals the dimension of the
-   * image space.
-   */
-  size_type n_rows () const;
-
-  /**
-   * Return number of columns of this matrix, which equals the dimension of
-   * the range space.
-   */
-  size_type n_cols () const;
-
-  /**
-   * Number of entries in a specific row.
-   */
-  size_type row_length (const size_type row) const;
-
-  /**
-   * Access to column number field. Return the column number of the @p indexth
-   * entry in @p row.
-   */
-  size_type column_number (const size_type row,
-                           const size_type index) const;
-
-  /**
-   * Return an iterator that can loop over all entries in the given row.
-   * Dereferencing the iterator yields a column index.
-   */
-  row_iterator row_begin (const size_type row) const;
-
-  /**
-   * Returns the end of the current row.
-   */
-  row_iterator row_end (const size_type row) const;
-
-  /**
-   * Compute the bandwidth of the matrix represented by this structure. The
-   * bandwidth is the maximum of $|i-j|$ for which the index pair $(i,j)$
-   * represents a nonzero entry of the matrix.
-   */
-  size_type bandwidth () const;
-
-  /**
-   * Return the number of nonzero elements allocated through this sparsity
-   * pattern.
-   */
-  size_type n_nonzero_elements () const;
-
-  /**
-   * Return whether this object stores only those entries that have been added
-   * explicitly, or if the sparsity pattern contains elements that have been
-   * added through other means (implicitly) while building it. For the current
-   * class, the result is always true.
-   *
-   * This function mainly serves the purpose of describing the current class
-   * in cases where several kinds of sparsity patterns can be passed as
-   * template arguments.
-   */
-  static
-  bool stores_only_added_elements ();
-
-private:
-  /**
-   * Number of rows that this sparsity structure shall represent.
-   */
-  size_type rows;
-
-  /**
-   * Number of columns that this sparsity structure shall represent.
-   */
-  size_type cols;
-
-  /**
-   * Store some data for each row describing which entries of this row are
-   * nonzero. Data is organized as follows: if an entry is added to a row, it
-   * is first added to the #cache variable, irrespective of whether an entry
-   * with same column number has already been added. Only if the cache is full
-   * do we flush it by removing duplicates, removing entries that are already
-   * stored in the @p entries array, sorting everything, and merging the two
-   * arrays.
-   *
-   * The reasoning behind this scheme is that memory allocation is expensive,
-   * and we only want to do it when really necessary. Previously (in deal.II
-   * versions up to 5.0), we used to store the column indices inside a
-   * std::set, but this would allocate 20 bytes each time we added an entry.
-   * (A std::set based class has later been revived in form of the
-   * CompressedSetSparsityPattern class, as this turned out to be more
-   * efficient for hp finite element programs such as step-27). Using the
-   * present scheme, we only need to allocate memory once for every 8 added
-   * entries, and we waste a lot less memory by not using a balanced tree for
-   * storing column indices.
-   *
-   * Since some functions that are @p const need to access the data of this
-   * object, but need to flush caches before, the flush_cache() function is
-   * marked const, and the data members are marked @p mutable.
-   *
-   * A small testseries about the size of the cache showed that the run time
-   * of a small program just testing the compressed sparsity pattern element
-   * insertion routine ran for 3.6 seconds with a cache size of 8, and 4.2
-   * seconds with a cache size of 16. We deem even smaller cache sizes
-   * undesirable, since they lead to more memory allocations, while larger
-   * cache sizes lead to waste of memory. The original version of this class,
-   * with one std::set per row took 8.2 seconds on the same program.
-   */
-  struct Line
-  {
-  private:
-    /**
-     * Size of the cache.
-     */
-    static const unsigned int cache_size = 8;
-
-  public:
-    /**
-     * Storage for the column indices of this row, unless they are still in
-     * the cache. This array is always kept sorted.
-     */
-    mutable std::vector<size_type> entries;
-
-    /**
-     * Cache of entries that have not yet been written to #entries;
-     */
-    mutable size_type cache[cache_size];
-
-    /**
-     * Number of entries in the cache.
-     */
-    mutable unsigned int cache_entries;
-
-    /**
-     * Constructor.
-     */
-    Line ();
-
-    /**
-     * Add the given column number to this line.
-     */
-    void add (const size_type col_num);
-
-    /**
-     * Add the columns specified by the iterator range to this line.
-     */
-    template <typename ForwardIterator>
-    void add_entries (ForwardIterator begin,
-                      ForwardIterator end,
-                      const bool indices_are_sorted);
-
-    /**
-     * Flush the cache my merging it with the #entries array.
-     */
-    void flush_cache () const;
-  };
-
-
-  /**
-   * Actual data: store for each row the set of nonzero entries.
-   */
-  std::vector<Line> lines;
-};
+typedef DynamicSparsityPattern CompressedSparsityPattern DEAL_II_DEPRECATED;
 
 /*@}*/
-/*---------------------- Inline functions -----------------------------------*/
-
-
-inline
-void
-CompressedSparsityPattern::Line::add (const size_type j)
-{
-  // first check whether this entry is
-  // already in the cache. if so, we can
-  // safely return
-  for (unsigned int i=0; i<cache_entries; ++i)
-    if (cache[i] == j)
-      return;
-
-  // if not, see whether there is still some
-  // space in the cache. if not, then flush
-  // the cache first
-  if (cache_entries == cache_size && cache_entries != 0)
-    flush_cache ();
-
-  cache[cache_entries] = j;
-  ++cache_entries;
-}
-
-
-
-inline
-types::global_dof_index
-CompressedSparsityPattern::n_rows () const
-{
-  return rows;
-}
-
-
-
-inline
-types::global_dof_index
-CompressedSparsityPattern::n_cols () const
-{
-  return cols;
-}
-
-
-
-inline
-void
-CompressedSparsityPattern::add (const size_type i,
-                                const size_type j)
-{
-  Assert (i<rows, ExcIndexRangeType<size_type>(i, 0, rows));
-  Assert (j<cols, ExcIndexRangeType<size_type>(j, 0, cols));
-
-  lines[i].add (j);
-}
-
-
-
-template <typename ForwardIterator>
-inline
-void
-CompressedSparsityPattern::add_entries (const size_type row,
-                                        ForwardIterator begin,
-                                        ForwardIterator end,
-                                        const bool      indices_are_sorted)
-{
-  Assert (row < rows, ExcIndexRange (row, 0, rows));
-
-  lines[row].add_entries (begin, end, indices_are_sorted);
-}
-
-
-
-inline
-CompressedSparsityPattern::Line::Line ()
-  :
-  cache_entries (0)
-{}
-
-
-
-inline
-types::global_dof_index
-CompressedSparsityPattern::row_length (const size_type row) const
-{
-  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
-
-  if (lines[row].cache_entries != 0)
-    lines[row].flush_cache ();
-  return lines[row].entries.size();
-}
-
-
-
-inline
-types::global_dof_index
-CompressedSparsityPattern::column_number (const size_type row,
-                                          const size_type index) const
-{
-  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
-  Assert (index < lines[row].entries.size(),
-          ExcIndexRangeType<size_type> (index, 0, lines[row].entries.size()));
-
-  if (lines[row].cache_entries != 0)
-    lines[row].flush_cache ();
-  return lines[row].entries[index];
-}
-
-
-
-inline
-CompressedSparsityPattern::row_iterator
-CompressedSparsityPattern::row_begin (const size_type row) const
-{
-  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
-
-  if (lines[row].cache_entries != 0)
-    lines[row].flush_cache ();
-  return lines[row].entries.begin();
-}
-
-
-
-inline
-CompressedSparsityPattern::row_iterator
-CompressedSparsityPattern::row_end (const size_type row) const
-{
-  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
-  return lines[row].entries.end();
-}
-
-
-
-inline
-bool
-CompressedSparsityPattern::stores_only_added_elements ()
-{
-  return true;
-}
-
-
-
 
 DEAL_II_NAMESPACE_CLOSE
 
index d237a179166f8b147f6b57415458ba19f4cc63ba..64de8f3d6c02e7668a8c14ee89859d373466672e 100644 (file)
@@ -40,13 +40,9 @@ DEAL_II_NAMESPACE_OPEN
 template<int dim, class T> class Table;
 template <typename> class FullMatrix;
 class SparsityPattern;
-class CompressedSparsityPattern;
-class CompressedSetSparsityPattern;
-class CompressedSimpleSparsityPattern;
+class DynamicSparsityPattern;
 class BlockSparsityPattern;
-class BlockCompressedSparsityPattern;
-class BlockCompressedSetSparsityPattern;
-class BlockCompressedSimpleSparsityPattern;
+class BlockDynamicSparsityPattern;
 template <typename number> class SparseMatrix;
 template <typename number> class BlockSparseMatrix;
 class BlockIndices;
@@ -544,63 +540,17 @@ public:
    */
   void condense (BlockSparsityPattern &sparsity) const;
 
-  /**
-   * Same function as above, but condenses square compressed sparsity
-   * patterns.
-   *
-   * Given the data structure used by CompressedSparsityPattern, this function
-   * becomes quadratic in the number of degrees of freedom for large problems
-   * and can dominate setting up linear systems when several hundred thousand
-   * or millions of unknowns are involved and for problems with many nonzero
-   * elements per row (for example for vector-valued problems or hp finite
-   * elements). In this case, it is advisable to use the
-   * CompressedSetSparsityPattern class instead, see for example
-   * @ref step_27 "step-27",
-   * or to use the CompressedSimpleSparsityPattern class, see for example
-   * @ref step_31 "step-31".
-   */
-  void condense (CompressedSparsityPattern &sparsity) const;
-
-  /**
-   * Same function as above, but condenses compressed sparsity patterns, which
-   * are based on the std::set container.
-   */
-  void condense (CompressedSetSparsityPattern &sparsity) const;
-
-  /**
-   * Same function as above, but condenses compressed sparsity patterns, which
-   * are based on the ''simple'' aproach.
-   */
-  void condense (CompressedSimpleSparsityPattern &sparsity) const;
-
-  /**
-   * Same function as above, but condenses square compressed sparsity
-   * patterns.
-   *
-   * Given the data structure used by BlockCompressedSparsityPattern, this
-   * function becomes quadratic in the number of degrees of freedom for large
-   * problems and can dominate setting up linear systems when several hundred
-   * thousand or millions of unknowns are involved and for problems with many
-   * nonzero elements per row (for example for vector-valued problems or hp
-   * finite elements). In this case, it is advisable to use the
-   * BlockCompressedSetSparsityPattern class instead, see for example
-   * @ref step_27 "step-27"
-   * and
-   * @ref step_31 "step-31".
-   */
-  void condense (BlockCompressedSparsityPattern &sparsity) const;
-
   /**
    * Same function as above, but condenses square compressed sparsity
    * patterns.
    */
-  void condense (BlockCompressedSetSparsityPattern &sparsity) const;
+  void condense (DynamicSparsityPattern &sparsity) const;
 
   /**
    * Same function as above, but condenses square compressed sparsity
    * patterns.
    */
-  void condense (BlockCompressedSimpleSparsityPattern &sparsity) const;
+  void condense (BlockDynamicSparsityPattern &sparsity) const;
 
   /**
    * Condense a given matrix, i.e., eliminate the rows and columns of the
diff --git a/include/deal.II/lac/dynamic_sparsity_pattern.h b/include/deal.II/lac/dynamic_sparsity_pattern.h
new file mode 100644 (file)
index 0000000..4078822
--- /dev/null
@@ -0,0 +1,528 @@
+// ---------------------------------------------------------------------
+//
+// Copyright (C) 2011 - 2015 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+#ifndef __deal2__dynamic_sparsity_pattern_h
+#define __deal2__dynamic_sparsity_pattern_h
+
+
+#include <deal.II/base/config.h>
+#include <deal.II/base/subscriptor.h>
+#include <deal.II/base/utilities.h>
+#include <deal.II/lac/exceptions.h>
+#include <deal.II/base/index_set.h>
+
+#include <vector>
+#include <algorithm>
+#include <iostream>
+
+DEAL_II_NAMESPACE_OPEN
+
+template <typename number> class SparseMatrix;
+
+
+/*! @addtogroup Sparsity
+ *@{
+ */
+
+
+/**
+ * This class acts as an intermediate form of the SparsityPattern class. From
+ * the interface it mostly represents a SparsityPattern object that is kept
+ * compressed at all times. However, since the final sparsity pattern is not
+ * known while constructing it, keeping the pattern compressed at all times
+ * can only be achieved at the expense of either increased memory or run time
+ * consumption upon use. The main purpose of this class is to avoid some
+ * memory bottlenecks, so we chose to implement it memory conservative. The
+ * chosen data format is too unsuited to be used for actual matrices, though.
+ * It is therefore necessary to first copy the data of this object over to an
+ * object of type SparsityPattern before using it in actual matrices.
+ *
+ * Another viewpoint is that this class does not need up front allocation of a
+ * certain amount of memory, but grows as necessary.  An extensive description
+ * of sparsity patterns can be found in the documentation of the
+ * @ref Sparsity
+ * module.
+ *
+ * This class is an example of the "dynamic" type of
+ * @ref Sparsity.
+ *
+ * <h3>Interface</h3>
+ *
+ * Since this class is intended as an intermediate replacement of the
+ * SparsityPattern class, it has mostly the same interface, with small changes
+ * where necessary. In particular, the add() function, and the functions
+ * inquiring properties of the sparsity pattern are the same.
+ *
+ *
+ * <h3>Usage</h3>
+ *
+ * Use this class as follows:
+ * @code
+ * DynamicSparsityPattern compressed_pattern (dof_handler.n_dofs());
+ * DoFTools::make_sparsity_pattern (dof_handler,
+ *                                  compressed_pattern);
+ * constraints.condense (compressed_pattern);
+ *
+ * SparsityPattern sp;
+ * sp.copy_from (compressed_pattern);
+ * @endcode
+ *
+ * @author Timo Heister, 2008
+ */
+class DynamicSparsityPattern : public Subscriptor
+{
+public:
+  /**
+   * Declare the type for container size.
+   */
+  typedef types::global_dof_index size_type;
+
+  /**
+   * An iterator that can be used to iterate over the elements of a single
+   * row. The result of dereferencing such an iterator is a column index.
+   */
+  typedef std::vector<size_type>::const_iterator row_iterator;
+
+  /**
+   * Initialize as an empty object. This is
+   * useful if you want such objects as member variables in other classes. You
+   * can make the structure usable by calling the reinit() function.
+   */
+  DynamicSparsityPattern ();
+
+  /**
+   * Copy constructor. This constructor is only allowed to be called if the
+   * sparsity structure to be copied is empty. This is so in order to prevent
+   * involuntary copies of objects for temporaries, which can use large
+   * amounts of computing time.  However, copy constructors are needed if you
+   * want to use the STL data types on classes like this, e.g. to write such
+   * statements like <tt>v.push_back (DynamicSparsityPattern());</tt>, with
+   * @p v a vector of @p DynamicSparsityPattern objects.
+   */
+  DynamicSparsityPattern (const DynamicSparsityPattern &);
+
+  /**
+   * Initialize a rectangular sparsity pattern with @p m rows and @p n columns. The @p
+   * rowset restricts the storage to elements in rows of this set.  Adding
+   * elements outside of this set has no effect. The default argument keeps
+   * all entries.
+   */
+  DynamicSparsityPattern (const size_type m,
+                          const size_type n,
+                          const IndexSet &rowset = IndexSet());
+
+  /**
+   * Create a square SparsityPattern using the index set.
+   */
+  DynamicSparsityPattern (const IndexSet &indexset);
+
+  /**
+   * Initialize a square pattern of dimension @p n.
+   */
+  DynamicSparsityPattern (const size_type n);
+
+  /**
+   * Copy operator. For this the same holds as for the copy constructor: it is
+   * declared, defined and fine to be called, but the latter only for empty
+   * objects.
+   */
+  DynamicSparsityPattern &operator = (const DynamicSparsityPattern &);
+
+  /**
+   * Reallocate memory and set up data structures for a new sparsity pattern with @p m
+   * rows and @p n columns. The @p rowset restricts the storage to elements in rows of this
+   * set.  Adding elements outside of this set has no effect. The default
+   * argument keeps all entries.
+   */
+  void reinit (const size_type m,
+               const size_type n,
+               const IndexSet &rowset = IndexSet());
+
+  /**
+   * Since this object is kept compressed at all times anyway, this function
+   * does nothing, but is declared to make the interface of this class as much
+   * alike as that of the SparsityPattern class.
+   */
+  void compress ();
+
+  /**
+   * Return whether the object is empty. It is empty if no memory is
+   * allocated, which is the same as that both dimensions are zero.
+   */
+  bool empty () const;
+
+  /**
+   * Return the maximum number of entries per row. Note that this number may
+   * change as entries are added.
+   */
+  size_type max_entries_per_row () const;
+
+  /**
+   * Add a nonzero entry. If the entry already exists, this call does nothing.
+   */
+  void add (const size_type i,
+            const size_type j);
+
+  /**
+   * Add several nonzero entries to the specified row. Already existing entries are ignored.
+   */
+  template <typename ForwardIterator>
+  void add_entries (const size_type row,
+                    ForwardIterator begin,
+                    ForwardIterator end,
+                    const bool      indices_are_unique_and_sorted = false);
+
+  /**
+   * Check if a value at a certain position may be non-zero.
+   */
+  bool exists (const size_type i,
+               const size_type j) const;
+
+  /**
+   * Make the sparsity pattern symmetric by adding the sparsity pattern of the
+   * transpose object.
+   *
+   * This function throws an exception if the sparsity pattern does not
+   * represent a square matrix.
+   */
+  void symmetrize ();
+
+  /**
+   * Print the sparsity pattern. The output consists of one line per row
+   * of the format <tt>[i,j1,j2,j3,...]</tt>. <i>i</i> is the row number and
+   * <i>jn</i> are the allocated columns in this row.
+   */
+  void print (std::ostream &out) const;
+
+  /**
+   * Print the sparsity pattern in a format that @p gnuplot understands
+   * and which can be used to plot the sparsity pattern in a graphical way.
+   * The format consists of pairs <tt>i j</tt> of nonzero elements, each
+   * representing one entry, one per line of the output file.
+   * Indices are counted from zero on, as usual. Since sparsity patterns are
+   * printed in the same way as matrices are displayed, we print the negative
+   * of the column index, which means that the <tt>(0,0)</tt> element is in
+   * the top left rather than in the bottom left corner.
+   *
+   * Print the sparsity pattern in gnuplot by setting the data style to dots
+   * or points and use the @p plot command.
+   */
+  void print_gnuplot (std::ostream &out) const;
+
+  /**
+   * Return the number of rows, which equals the dimension of the
+   * image space.
+   */
+  size_type n_rows () const;
+
+  /**
+   * Return the number of columns, which equals the dimension of
+   * the range space.
+   */
+  size_type n_cols () const;
+
+  /**
+   * Number of entries in a specific row. This function can only be called if
+   * the given row is a member of the index set of rows that we want to store.
+   */
+  size_type row_length (const size_type row) const;
+
+  /**
+   * Access to column number field.  Return the column number of the @p
+   * indexth entry in @p row.
+   */
+  size_type column_number (const size_type row,
+                           const size_type index) const;
+
+  /**
+   * Return an iterator that can loop over all entries in the given row.
+   * Dereferencing the iterator yields a column index.
+   */
+  row_iterator row_begin (const size_type row) const;
+
+  /**
+   * Returns the end of the current row.
+   */
+  row_iterator row_end (const size_type row) const;
+  /**
+   * Compute the bandwidth of the matrix represented by this structure. The
+   * bandwidth is the maximum of $|i-j|$ for which the index pair $(i,j)$
+   * represents a nonzero entry of the matrix.
+   */
+  size_type bandwidth () const;
+
+  /**
+   * Return the number of nonzero elements allocated through this sparsity
+   * pattern.
+   */
+  size_type n_nonzero_elements () const;
+
+  /**
+   * Return the IndexSet that sets which rows are active on the current
+   * processor. It corresponds to the IndexSet given to this class in the
+   * constructor or in the reinit function.
+   */
+  const IndexSet &row_index_set () const;
+
+  /**
+   * return whether this object stores only those entries that have been added
+   * explicitly, or if the sparsity pattern contains elements that have been
+   * added through other means (implicitly) while building it. For the current
+   * class, the result is always true.
+   *
+   * This function mainly serves the purpose of describing the current class
+   * in cases where several kinds of sparsity patterns can be passed as
+   * template arguments.
+   */
+  static
+  bool stores_only_added_elements ();
+
+  /**
+   * Determine an estimate for the memory consumption (in bytes) of this
+   * object.
+   */
+  size_type memory_consumption () const;
+
+private:
+  /**
+   * Number of rows that this sparsity structure shall represent.
+   */
+  size_type rows;
+
+  /**
+   * Number of columns that this sparsity structure shall represent.
+   */
+  size_type cols;
+
+  /**
+   * A set that contains the valid rows.
+   */
+
+  IndexSet rowset;
+
+
+  /**
+   * Store some data for each row describing which entries of this row are
+   * nonzero. Data is stored sorted in the @p entries std::vector.  The vector
+   * per row is dynamically growing upon insertion doubling its memory each
+   * time.
+   */
+  struct Line
+  {
+  public:
+    /**
+     * Storage for the column indices of this row. This array is always kept
+     * sorted.
+     */
+    std::vector<size_type> entries;
+
+    /**
+     * Constructor.
+     */
+    Line ();
+
+    /**
+     * Add the given column number to this line.
+     */
+    void add (const size_type col_num);
+
+    /**
+     * Add the columns specified by the iterator range to this line.
+     */
+    template <typename ForwardIterator>
+    void add_entries (ForwardIterator begin,
+                      ForwardIterator end,
+                      const bool indices_are_sorted);
+
+    /**
+     * estimates memory consumption.
+     */
+    size_type memory_consumption () const;
+  };
+
+
+  /**
+   * Actual data: store for each row the set of nonzero entries.
+   */
+  std::vector<Line> lines;
+};
+
+/*@}*/
+/*---------------------- Inline functions -----------------------------------*/
+
+
+inline
+void
+DynamicSparsityPattern::Line::add (const size_type j)
+{
+  // first check the last element (or if line is still empty)
+  if ( (entries.size()==0) || ( entries.back() < j) )
+    {
+      entries.push_back(j);
+      return;
+    }
+
+  // do a binary search to find the place where to insert:
+  std::vector<size_type>::iterator
+  it = Utilities::lower_bound(entries.begin(),
+                              entries.end(),
+                              j);
+
+  // If this entry is a duplicate, exit immediately
+  if (*it == j)
+    return;
+
+  // Insert at the right place in the vector. Vector grows automatically to
+  // fit elements. Always doubles its size.
+  entries.insert(it, j);
+}
+
+
+
+inline
+DynamicSparsityPattern::size_type
+DynamicSparsityPattern::n_rows () const
+{
+  return rows;
+}
+
+
+
+inline
+types::global_dof_index
+DynamicSparsityPattern::n_cols () const
+{
+  return cols;
+}
+
+
+
+inline
+void
+DynamicSparsityPattern::add (const size_type i,
+                             const size_type j)
+{
+  Assert (i<rows, ExcIndexRangeType<size_type>(i, 0, rows));
+  Assert (j<cols, ExcIndexRangeType<size_type>(j, 0, cols));
+
+  if (rowset.size() > 0 && !rowset.is_element(i))
+    return;
+
+  const size_type rowindex =
+    rowset.size()==0 ? i : rowset.index_within_set(i);
+  lines[rowindex].add (j);
+}
+
+
+
+template <typename ForwardIterator>
+inline
+void
+DynamicSparsityPattern::add_entries (const size_type row,
+                                     ForwardIterator begin,
+                                     ForwardIterator end,
+                                     const bool      indices_are_sorted)
+{
+  Assert (row < rows, ExcIndexRangeType<size_type> (row, 0, rows));
+
+  if (rowset.size() > 0 && !rowset.is_element(row))
+    return;
+
+  const size_type rowindex =
+    rowset.size()==0 ? row : rowset.index_within_set(row);
+  lines[rowindex].add_entries (begin, end, indices_are_sorted);
+}
+
+
+
+inline
+DynamicSparsityPattern::Line::Line ()
+{}
+
+
+
+inline
+types::global_dof_index
+DynamicSparsityPattern::row_length (const size_type row) const
+{
+  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
+  if (rowset.size() > 0 && !rowset.is_element(row))
+    return 0;
+
+  const size_type rowindex =
+    rowset.size()==0 ? row : rowset.index_within_set(row);
+  return lines[rowindex].entries.size();
+}
+
+
+
+inline
+types::global_dof_index
+DynamicSparsityPattern::column_number (const size_type row,
+                                       const size_type index) const
+{
+  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
+  Assert( rowset.size() == 0 || rowset.is_element(row), ExcInternalError());
+
+  const size_type local_row = rowset.size() ? rowset.index_within_set(row) : row;
+  Assert (index < lines[local_row].entries.size(),
+          ExcIndexRangeType<size_type> (index, 0, lines[local_row].entries.size()));
+  return lines[local_row].entries[index];
+}
+
+
+
+inline
+DynamicSparsityPattern::row_iterator
+DynamicSparsityPattern::row_begin (const size_type row) const
+{
+  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
+  const size_type local_row = rowset.size() ? rowset.index_within_set(row) : row;
+  return lines[local_row].entries.begin();
+}
+
+
+
+inline
+DynamicSparsityPattern::row_iterator
+DynamicSparsityPattern::row_end (const size_type row) const
+{
+  Assert (row < n_rows(), ExcIndexRangeType<size_type> (row, 0, n_rows()));
+  const size_type local_row = rowset.size() ? rowset.index_within_set(row) : row;
+  return lines[local_row].entries.end();
+}
+
+
+
+inline
+const IndexSet &
+DynamicSparsityPattern::row_index_set () const
+{
+  return rowset;
+}
+
+
+
+inline
+bool
+DynamicSparsityPattern::stores_only_added_elements ()
+{
+  return true;
+}
+
+
+DEAL_II_NAMESPACE_CLOSE
+
+#endif
index 25a5ba06487d1835defc94c39030eaa6e342b554..12f319eab422301d412bf5173d3f191fe81956bd 100644 (file)
@@ -91,7 +91,7 @@ namespace LinearAlgebraPETSc
      */
     typedef PETScWrappers::MPI::BlockSparseMatrix BlockSparseMatrix;
 
-    typedef dealii::BlockCompressedSimpleSparsityPattern BlockCompressedSparsityPattern;
+    typedef dealii::BlockDynamicSparsityPattern BlockCompressedSparsityPattern;
 
     /**
      * Typedef for the AMG preconditioner type.
index 63efc40e256a1eddfaaed4beade3a8945424228f..61ae9a1bcffccaa990f553b856d2f3b8e2455300 100644 (file)
@@ -155,7 +155,7 @@ namespace PETScWrappers
        */
       void reinit(const std::vector<IndexSet> &rows,
                   const std::vector<IndexSet> &cols,
-                  const BlockCompressedSimpleSparsityPattern &bcsp,
+                  const BlockDynamicSparsityPattern &bcsp,
                   const MPI_Comm &com);
 
 
@@ -163,7 +163,7 @@ namespace PETScWrappers
        * Same as above but for a symmetric structure only.
        */
       void reinit(const std::vector<IndexSet> &sizes,
-                  const BlockCompressedSimpleSparsityPattern &bcsp,
+                  const BlockDynamicSparsityPattern &bcsp,
                   const MPI_Comm &com);
 
 
index 011cdbb472a538a85c13fd1cc5af11518a2ef151..eac33c0f2dd8fba0dfb9fceb6277bf0c92516c37 100644 (file)
@@ -36,11 +36,6 @@ template <typename number> class SparseLUDecomposition;
 template <typename number> class SparseILU;
 template <class VECTOR> class VectorSlice;
 
-class CompressedSparsityPattern;
-class CompressedSetSparsityPattern;
-class CompressedSimpleSparsityPattern;
-
-
 namespace ChunkSparsityPatternIterators
 {
   class Accessor;
index 1249b739e4acaf6b8cd24de853977b2075cf775e..179411b0612fb2478aa0f1cf012c2a04a8ad3815 100644 (file)
@@ -37,9 +37,6 @@ DEAL_II_NAMESPACE_OPEN
 
 // forward declarations
 class BlockSparsityPattern;
-class BlockCompressedSparsityPattern;
-class BlockCompressedSetSparsityPattern;
-class BlockCompressedSimpleSparsityPattern;
 template <typename number> class BlockSparseMatrix;
 
 
index cbbc973d8e2f86020fa921ad45386254a2bc3adf..86a9fe81a3b780e92983cd56d969eed2d55ffe1a 100644 (file)
@@ -44,9 +44,7 @@ DEAL_II_NAMESPACE_OPEN
 
 // forward declarations
 class SparsityPattern;
-class CompressedSparsityPattern;
-class CompressedSetSparsityPattern;
-class CompressedSimpleSparsityPattern;
+class DynamicSparsityPattern;
 
 namespace TrilinosWrappers
 {
index 349c6fcb82b528f6a3afd17b0e27b1d94a43da8c..1bd8435f55c50951ad0942729701a3ecd67e0eb0 100644 (file)
@@ -22,6 +22,7 @@
 #include <deal.II/base/vectorization.h>
 #include <deal.II/base/partitioner.h>
 #include <deal.II/lac/constraint_matrix.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/dofs/dof_handler.h>
 #include <deal.II/matrix_free/helper_functions.h>
 
@@ -265,7 +266,7 @@ namespace internal
                                const std::vector<unsigned int> &renumbering,
                                const std::vector<unsigned int> &irregular_cells,
                                const bool                       do_blocking,
-                               CompressedSimpleSparsityPattern &connectivity) const;
+                               DynamicSparsityPattern &connectivity) const;
 
       /**
        * Renumbers the degrees of freedom to give good access for this class.
index ca4049c55d9db8647459a116c391b167d7e330bf..a02bf78ef0cdbbf1a2bc94166ad3c2d04919cb2e 100644 (file)
@@ -16,7 +16,7 @@
 
 #include <deal.II/base/memory_consumption.h>
 #include <deal.II/base/multithread_info.h>
-#include <deal.II/lac/compressed_simple_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/sparsity_pattern.h>
 #include <deal.II/matrix_free/dof_info.h>
 #include <deal.II/matrix_free/helper_functions.h>
@@ -913,7 +913,7 @@ no_constraint:
                                   (task_info.block_size*(task_info.n_blocks-1));
 
       // create the connectivity graph with internal blocking
-      CompressedSimpleSparsityPattern connectivity;
+      DynamicSparsityPattern connectivity;
       make_connectivity_graph (size_info, task_info, renumbering,irregular_cells,
                                true, connectivity);
 
@@ -977,7 +977,7 @@ no_constraint:
                 {
                   Assert(cell_partition[neighbor_list[j]]==partition-1,
                          ExcInternalError());
-                  CompressedSimpleSparsityPattern::row_iterator neighbor =
+                  DynamicSparsityPattern::row_iterator neighbor =
                     connectivity.row_begin(neighbor_list[j]),
                     end = connectivity.row_end(neighbor_list[j]);
                   for (; neighbor!=end ; ++neighbor)
@@ -1027,7 +1027,7 @@ no_constraint:
               color_finder.resize(n_neighbors+1);
               for (unsigned int j=0; j<=n_neighbors; ++j)
                 color_finder[j]=true;
-              CompressedSimpleSparsityPattern::row_iterator
+              DynamicSparsityPattern::row_iterator
               neighbor = connectivity.row_begin(cell),
               end      = connectivity.row_end(cell);
               for (; neighbor!=end ; ++neighbor)
@@ -1167,7 +1167,7 @@ no_constraint:
       unsigned int cluster_size = task_info.block_size*vectorization_length;
 
       // create the connectivity graph without internal blocking
-      CompressedSimpleSparsityPattern connectivity;
+      DynamicSparsityPattern connectivity;
       make_connectivity_graph (size_info, task_info, renumbering,irregular_cells,
                                false, connectivity);
 
@@ -1249,7 +1249,7 @@ no_constraint:
                 }
               index--;
               unsigned int additional = neighbor_list[index];
-              CompressedSimpleSparsityPattern::row_iterator neighbor =
+              DynamicSparsityPattern::row_iterator neighbor =
                 connectivity.row_begin(additional),
                 end = connectivity.row_end(additional);
               for (; neighbor!=end ; ++neighbor)
@@ -1277,7 +1277,7 @@ no_constraint:
                 {
                   Assert(cell_partition[neighbor_list[j]]==partition-1,
                          ExcInternalError());
-                  CompressedSimpleSparsityPattern::row_iterator neighbor =
+                  DynamicSparsityPattern::row_iterator neighbor =
                     connectivity.row_begin(neighbor_list[j]),
                     end = connectivity.row_end(neighbor_list[j]);
                   for (; neighbor!=end ; ++neighbor)
@@ -1312,7 +1312,7 @@ no_constraint:
                     }
                   index--;
                   unsigned int additional = neighbor_neighbor_list[index];
-                  CompressedSimpleSparsityPattern::row_iterator neighbor =
+                  DynamicSparsityPattern::row_iterator neighbor =
                     connectivity.row_begin(additional),
                     end = connectivity.row_end(additional);
                   for (; neighbor!=end ; ++neighbor)
@@ -1412,7 +1412,7 @@ not_connect:
                                ExcInternalError());
                         Assert(cell_partition_l2[neighbor_list[j]]==partition_l2-1,
                                ExcInternalError());
-                        CompressedSimpleSparsityPattern::row_iterator neighbor =
+                        DynamicSparsityPattern::row_iterator neighbor =
                           connectivity.row_begin(neighbor_list[j]),
                           end = connectivity.row_end(neighbor_list[j]);
                         for (; neighbor!=end ; ++neighbor)
@@ -1504,7 +1504,7 @@ not_connect:
                           // go through the neighbors of the last cell in the
                           // current partition and check if we find some to
                           // fill up with.
-                          CompressedSimpleSparsityPattern::row_iterator
+                          DynamicSparsityPattern::row_iterator
                           neighbor =
                             connectivity.row_begin(additional),
                             end = connectivity.row_end(additional);
@@ -1694,7 +1694,7 @@ not_connect:
      const std::vector<unsigned int> &renumbering,
      const std::vector<unsigned int> &irregular_cells,
      const bool                       do_blocking,
-     CompressedSimpleSparsityPattern &connectivity) const
+     DynamicSparsityPattern &connectivity) const
     {
       AssertDimension (row_starts.size()-1, size_info.n_active_cells);
       const unsigned int n_rows =
index 271e9486ba82e1d9f474e4b9826b89ffc1a78922..5f40c74ca4bc7e04dc646d47b8b84ea5ae29be92 100644 (file)
@@ -23,9 +23,7 @@ SET(_src
   block_vector.cc
   chunk_sparse_matrix.cc
   chunk_sparsity_pattern.cc
-  compressed_set_sparsity_pattern.cc
-  compressed_simple_sparsity_pattern.cc
-  compressed_sparsity_pattern.cc
+  dynamic_sparsity_pattern.cc
   constraint_matrix.cc
   full_matrix.cc
   lapack_full_matrix.cc
index de0de1ef457abf411b4512e4e19b5c40e0f0417a..c177c2ecbee7fb0bc7f873844720ec6f785d4954 100644 (file)
@@ -270,7 +270,7 @@ BlockSparsityPatternBase<SparsityPatternBase>::print(std::ostream &out) const
 
 template <>
 void
-BlockSparsityPatternBase<CompressedSimpleSparsityPattern>::print(std::ostream &out) const
+BlockSparsityPatternBase<DynamicSparsityPattern>::print(std::ostream &out) const
 {
   size_type k=0;
   for (size_type ib=0; ib<n_block_rows(); ++ib)
@@ -281,7 +281,7 @@ BlockSparsityPatternBase<CompressedSimpleSparsityPattern>::print(std::ostream &o
           size_type l=0;
           for (size_type jb=0; jb<n_block_cols(); ++jb)
             {
-              const CompressedSimpleSparsityPattern &b = block(ib,jb);
+              const DynamicSparsityPattern &b = block(ib,jb);
               if (b.row_index_set().size()==0 || b.row_index_set().is_element(i))
                 for (size_type j=0; j<b.n_cols(); ++j)
                   if (b.exists(i,j))
@@ -336,9 +336,7 @@ BlockSparsityPatternBase<SparsityPatternBase>::print_gnuplot(std::ostream &out)
 
 
 template class BlockSparsityPatternBase<SparsityPattern>;
-template class BlockSparsityPatternBase<CompressedSparsityPattern>;
-template class BlockSparsityPatternBase<CompressedSimpleSparsityPattern>;
-template class BlockSparsityPatternBase<CompressedSetSparsityPattern>;
+template class BlockSparsityPatternBase<DynamicSparsityPattern>;
 #ifdef DEAL_II_WITH_TRILINOS
 template class BlockSparsityPatternBase<TrilinosWrappers::SparsityPattern>;
 #endif
@@ -421,7 +419,7 @@ BlockSparsityPattern::memory_consumption () const
 
 
 void
-BlockSparsityPattern::copy_from  (const BlockCompressedSparsityPattern &csp)
+BlockSparsityPattern::copy_from  (const BlockDynamicSparsityPattern &csp)
 {
   // delete old content, set block
   // sizes anew
@@ -437,189 +435,30 @@ BlockSparsityPattern::copy_from  (const BlockCompressedSparsityPattern &csp)
   collect_sizes();
 }
 
-void
-BlockSparsityPattern::copy_from  (const BlockCompressedSimpleSparsityPattern &csp)
-{
-  // delete old content, set block
-  // sizes anew
-  reinit (csp.n_block_rows(), csp.n_block_cols());
-
-  // copy over blocks
-  for (size_type i=0; i<rows; ++i)
-    for (size_type j=0; j<rows; ++j)
-      block(i,j).copy_from (csp.block(i,j));
-
-  // and finally enquire their new
-  // sizes
-  collect_sizes();
-}
-
-void
-BlockSparsityPattern::copy_from  (const BlockCompressedSetSparsityPattern &csp)
-{
-  // delete old content, set block
-  // sizes anew
-  reinit (csp.n_block_rows(), csp.n_block_cols());
-
-  // copy over blocks
-  for (size_type i=0; i<rows; ++i)
-    for (size_type j=0; j<rows; ++j)
-      block(i,j).copy_from (csp.block(i,j));
-
-  // and finally enquire their new
-  // sizes
-  collect_sizes();
-}
-
-
-
-BlockCompressedSparsityPattern::BlockCompressedSparsityPattern ()
-{}
-
-
-
-BlockCompressedSparsityPattern::
-BlockCompressedSparsityPattern (
-  const size_type n_rows,
-  const size_type n_columns)
-  :
-  BlockSparsityPatternBase<CompressedSparsityPattern>(n_rows,
-                                                      n_columns)
-{}
-
-
-BlockCompressedSparsityPattern::
-BlockCompressedSparsityPattern (
-  const std::vector<size_type> &row_indices,
-  const std::vector<size_type> &col_indices)
-{
-  reinit(row_indices, col_indices);
-}
-
-
-BlockCompressedSparsityPattern::
-BlockCompressedSparsityPattern (
-  const BlockIndices &row_indices,
-  const BlockIndices &col_indices)
-{
-  reinit(row_indices, col_indices);
-}
-
-
-void
-BlockCompressedSparsityPattern::reinit (
-  const std::vector<size_type> &row_block_sizes,
-  const std::vector<size_type> &col_block_sizes)
-{
-  BlockSparsityPatternBase<CompressedSparsityPattern>::reinit(row_block_sizes.size(), col_block_sizes.size());
-  for (size_type i=0; i<row_block_sizes.size(); ++i)
-    for (size_type j=0; j<col_block_sizes.size(); ++j)
-      this->block(i,j).reinit(row_block_sizes[i],col_block_sizes[j]);
-  this->collect_sizes();
-}
-
-
-
-void
-BlockCompressedSparsityPattern::reinit (
-  const BlockIndices &row_indices,
-  const BlockIndices &col_indices)
-{
-  BlockSparsityPatternBase<CompressedSparsityPattern>::reinit(row_indices.size(),
-                                                              col_indices.size());
-  for (size_type i=0; i<row_indices.size(); ++i)
-    for (size_type j=0; j<col_indices.size(); ++j)
-      this->block(i,j).reinit(row_indices.block_size(i),
-                              col_indices.block_size(j));
-  this->collect_sizes();
-}
-
-
-
-BlockCompressedSetSparsityPattern::BlockCompressedSetSparsityPattern ()
-{}
-
-
-
-BlockCompressedSetSparsityPattern::
-BlockCompressedSetSparsityPattern (
-  const size_type n_rows,
-  const size_type n_columns)
-  :
-  BlockSparsityPatternBase<CompressedSetSparsityPattern>(n_rows,
-                                                         n_columns)
-{}
-
-
-BlockCompressedSetSparsityPattern::
-BlockCompressedSetSparsityPattern (
-  const std::vector<size_type> &row_indices,
-  const std::vector<size_type> &col_indices)
-{
-  reinit(row_indices, col_indices);
-}
-
-
-BlockCompressedSetSparsityPattern::
-BlockCompressedSetSparsityPattern (
-  const BlockIndices &row_indices,
-  const BlockIndices &col_indices)
-{
-  reinit(row_indices, col_indices);
-}
-
-
-void
-BlockCompressedSetSparsityPattern::reinit (
-  const std::vector<size_type> &row_block_sizes,
-  const std::vector<size_type> &col_block_sizes)
-{
-  BlockSparsityPatternBase<CompressedSetSparsityPattern>::reinit(row_block_sizes.size(), col_block_sizes.size());
-  for (size_type i=0; i<row_block_sizes.size(); ++i)
-    for (size_type j=0; j<col_block_sizes.size(); ++j)
-      this->block(i,j).reinit(row_block_sizes[i],col_block_sizes[j]);
-  this->collect_sizes();
-}
-
-
-
-void
-BlockCompressedSetSparsityPattern::reinit (
-  const BlockIndices &row_indices,
-  const BlockIndices &col_indices)
-{
-  BlockSparsityPatternBase<CompressedSetSparsityPattern>::reinit(row_indices.size(),
-      col_indices.size());
-  for (size_type i=0; i<row_indices.size(); ++i)
-    for (size_type j=0; j<col_indices.size(); ++j)
-      this->block(i,j).reinit(row_indices.block_size(i),
-                              col_indices.block_size(j));
-  this->collect_sizes();
-}
 
 
 
-BlockCompressedSimpleSparsityPattern::BlockCompressedSimpleSparsityPattern ()
+BlockDynamicSparsityPattern::BlockDynamicSparsityPattern ()
 {}
 
 
 
-BlockCompressedSimpleSparsityPattern::
-BlockCompressedSimpleSparsityPattern (const size_type n_rows,
-                                      const size_type n_columns)
+BlockDynamicSparsityPattern::
+BlockDynamicSparsityPattern (const size_type n_rows,
+                             const size_type n_columns)
   :
-  BlockSparsityPatternBase<CompressedSimpleSparsityPattern>(n_rows,
-                                                            n_columns)
+  BlockSparsityPatternBase<DynamicSparsityPattern>(n_rows,
+                                                   n_columns)
 {}
 
 
 
-BlockCompressedSimpleSparsityPattern::
-BlockCompressedSimpleSparsityPattern (const std::vector<size_type> &row_indices,
-                                      const std::vector<size_type> &col_indices)
+BlockDynamicSparsityPattern::
+BlockDynamicSparsityPattern (const std::vector<size_type> &row_indices,
+                             const std::vector<size_type> &col_indices)
   :
-  BlockSparsityPatternBase<CompressedSimpleSparsityPattern>(row_indices.size(),
-                                                            col_indices.size())
+  BlockSparsityPatternBase<DynamicSparsityPattern>(row_indices.size(),
+                                                   col_indices.size())
 {
   for (size_type i=0; i<row_indices.size(); ++i)
     for (size_type j=0; j<col_indices.size(); ++j)
@@ -628,11 +467,11 @@ BlockCompressedSimpleSparsityPattern (const std::vector<size_type> &row_indices,
 }
 
 
-BlockCompressedSimpleSparsityPattern::
-BlockCompressedSimpleSparsityPattern (const std::vector<IndexSet> &partitioning)
+BlockDynamicSparsityPattern::
+BlockDynamicSparsityPattern (const std::vector<IndexSet> &partitioning)
   :
-  BlockSparsityPatternBase<CompressedSimpleSparsityPattern>(partitioning.size(),
-                                                            partitioning.size())
+  BlockSparsityPatternBase<DynamicSparsityPattern>(partitioning.size(),
+                                                   partitioning.size())
 {
   for (size_type i=0; i<partitioning.size(); ++i)
     for (size_type j=0; j<partitioning.size(); ++j)
@@ -645,11 +484,11 @@ BlockCompressedSimpleSparsityPattern (const std::vector<IndexSet> &partitioning)
 
 
 void
-BlockCompressedSimpleSparsityPattern::reinit (
+BlockDynamicSparsityPattern::reinit (
   const std::vector<size_type> &row_block_sizes,
   const std::vector<size_type> &col_block_sizes)
 {
-  BlockSparsityPatternBase<CompressedSimpleSparsityPattern>::
+  BlockSparsityPatternBase<DynamicSparsityPattern>::
   reinit(row_block_sizes.size(), col_block_sizes.size());
   for (size_type i=0; i<row_block_sizes.size(); ++i)
     for (size_type j=0; j<col_block_sizes.size(); ++j)
@@ -658,10 +497,10 @@ BlockCompressedSimpleSparsityPattern::reinit (
 }
 
 void
-BlockCompressedSimpleSparsityPattern::reinit (
+BlockDynamicSparsityPattern::reinit (
   const std::vector< IndexSet > &partitioning)
 {
-  BlockSparsityPatternBase<CompressedSimpleSparsityPattern>::
+  BlockSparsityPatternBase<DynamicSparsityPattern>::
   reinit(partitioning.size(), partitioning.size());
   for (size_type i=0; i<partitioning.size(); ++i)
     for (size_type j=0; j<partitioning.size(); ++j)
index 02330e458a4d264e337beab638ca5f398fac574f..4c22a45ba0f3f06b3c33dd5deb58c4e45398c984 100644 (file)
@@ -201,7 +201,7 @@ ChunkSparsityPattern::copy_from (const SparsityType &csp,
   // sparsity pattern
   const size_type m_chunks = (csp.n_rows()+chunk_size-1) / chunk_size,
                   n_chunks = (csp.n_cols()+chunk_size-1) / chunk_size;
-  CompressedSimpleSparsityPattern temporary_sp(m_chunks, n_chunks);
+  DynamicSparsityPattern temporary_sp(m_chunks, n_chunks);
 
   for (size_type row = 0; row<csp.n_rows(); ++row)
     {
@@ -613,13 +613,7 @@ ChunkSparsityPattern::memory_consumption () const
 
 // explicit instantiations
 template
-void ChunkSparsityPattern::copy_from<CompressedSparsityPattern> (const CompressedSparsityPattern &,
-    const size_type);
-template
-void ChunkSparsityPattern::copy_from<CompressedSetSparsityPattern> (const CompressedSetSparsityPattern &,
-    const size_type);
-template
-void ChunkSparsityPattern::copy_from<CompressedSimpleSparsityPattern> (const CompressedSimpleSparsityPattern &,
+void ChunkSparsityPattern::copy_from<DynamicSparsityPattern> (const DynamicSparsityPattern &,
     const size_type);
 template
 void ChunkSparsityPattern::create_from<SparsityPattern>
@@ -629,27 +623,13 @@ void ChunkSparsityPattern::create_from<SparsityPattern>
  const unsigned int,
  const bool);
 template
-void ChunkSparsityPattern::create_from<CompressedSparsityPattern>
+void ChunkSparsityPattern::create_from<DynamicSparsityPattern>
 (const unsigned int,
  const unsigned int,
  const CompressedSparsityPattern &,
  const unsigned int,
  const bool);
 template
-void ChunkSparsityPattern::create_from<CompressedSetSparsityPattern>
-(const unsigned int,
- const unsigned int,
- const CompressedSetSparsityPattern &,
- const unsigned int,
- const bool);
-template
-void ChunkSparsityPattern::create_from<CompressedSimpleSparsityPattern>
-(const unsigned int,
- const unsigned int,
- const CompressedSimpleSparsityPattern &,
- const unsigned int,
- const bool);
-template
 void ChunkSparsityPattern::copy_from<float> (const FullMatrix<float> &,
                                              const size_type);
 template
diff --git a/source/lac/compressed_set_sparsity_pattern.cc b/source/lac/compressed_set_sparsity_pattern.cc
deleted file mode 100644 (file)
index 3bec4a3..0000000
+++ /dev/null
@@ -1,245 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2001 - 2014 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE at
-// the top level of the deal.II distribution.
-//
-// ---------------------------------------------------------------------
-
-#include <deal.II/lac/compressed_set_sparsity_pattern.h>
-
-#include <iostream>
-#include <iomanip>
-#include <algorithm>
-#include <cmath>
-#include <numeric>
-#include <functional>
-
-DEAL_II_NAMESPACE_OPEN
-
-
-
-CompressedSetSparsityPattern::CompressedSetSparsityPattern ()
-  :
-  rows(0),
-  cols(0)
-{}
-
-
-
-CompressedSetSparsityPattern::
-CompressedSetSparsityPattern (const CompressedSetSparsityPattern &s)
-  :
-  Subscriptor(),
-  rows(0),
-  cols(0)
-{
-  Assert (s.rows == 0, ExcInvalidConstructorCall());
-  Assert (s.cols == 0, ExcInvalidConstructorCall());
-}
-
-
-
-CompressedSetSparsityPattern::CompressedSetSparsityPattern (const size_type m,
-                                                            const size_type n)
-  :
-  rows(0),
-  cols(0)
-{
-  reinit (m,n);
-}
-
-
-
-CompressedSetSparsityPattern::CompressedSetSparsityPattern (const size_type n)
-  :
-  rows(0),
-  cols(0)
-{
-  reinit (n,n);
-}
-
-
-
-CompressedSetSparsityPattern &
-CompressedSetSparsityPattern::operator = (const CompressedSetSparsityPattern &s)
-{
-  Assert (s.rows == 0, ExcInvalidConstructorCall());
-  Assert (s.cols == 0, ExcInvalidConstructorCall());
-
-  Assert (rows == 0, ExcInvalidConstructorCall());
-  Assert (cols == 0, ExcInvalidConstructorCall());
-
-  return *this;
-}
-
-
-
-void
-CompressedSetSparsityPattern::reinit (const size_type m,
-                                      const size_type n)
-{
-  rows = m;
-  cols = n;
-
-  std::vector<Line> new_lines (rows);
-  lines.swap (new_lines);
-}
-
-
-
-void
-CompressedSetSparsityPattern::compress ()
-{}
-
-
-
-bool
-CompressedSetSparsityPattern::empty () const
-{
-  return ((rows==0) && (cols==0));
-}
-
-
-
-CompressedSetSparsityPattern::size_type
-CompressedSetSparsityPattern::max_entries_per_row () const
-{
-  size_type m = 0;
-  for (size_type i=0; i<rows; ++i)
-    {
-      m = std::max (m, static_cast<size_type>(lines[i].entries.size()));
-    }
-
-  return m;
-}
-
-
-
-bool
-CompressedSetSparsityPattern::exists (const size_type i,
-                                      const size_type j) const
-{
-  Assert (i<rows, ExcIndexRange(i, 0, rows));
-  Assert (j<cols, ExcIndexRange(j, 0, cols));
-
-  return (lines[i].entries.find (j) != lines[i].entries.end ());
-}
-
-
-
-void
-CompressedSetSparsityPattern::symmetrize ()
-{
-  Assert (rows==cols, ExcNotQuadratic());
-
-  // loop over all elements presently
-  // in the sparsity pattern and add
-  // the transpose element. note:
-  //
-  // 1. that the sparsity pattern
-  // changes which we work on, but
-  // not the present row
-  //
-  // 2. that the @p{add} function can
-  // be called on elements that
-  // already exist without any harm
-  for (size_type row=0; row<rows; ++row)
-    {
-      for (std::set<size_type>::const_iterator
-           j=lines[row].entries.begin();
-           j != lines[row].entries.end();
-           ++j)
-        // add the transpose entry if
-        // this is not the diagonal
-        if (row != *j)
-          add (*j, row);
-    }
-}
-
-
-
-void
-CompressedSetSparsityPattern::print (std::ostream &out) const
-{
-  AssertThrow (out, ExcIO());
-
-  for (size_type row=0; row<rows; ++row)
-    {
-      out << '[' << row;
-
-      for (std::set<size_type >::const_iterator
-           j=lines[row].entries.begin();
-           j != lines[row].entries.end(); ++j)
-        out << ',' << *j;
-
-      out << ']' << std::endl;
-    }
-
-  AssertThrow (out, ExcIO());
-}
-
-
-
-void
-CompressedSetSparsityPattern::print_gnuplot (std::ostream &out) const
-{
-  AssertThrow (out, ExcIO());
-
-  for (size_type row=0; row<rows; ++row)
-    {
-      for (std::set<size_type>::const_iterator
-           j=lines[row].entries.begin();
-           j != lines[row].entries.end(); ++j)
-        // while matrix entries are usually
-        // written (i,j), with i vertical and
-        // j horizontal, gnuplot output is
-        // x-y, that is we have to exchange
-        // the order of output
-        out << *j << " " << -static_cast<signed int>(row) << std::endl;
-    }
-
-
-  AssertThrow (out, ExcIO());
-}
-
-
-
-CompressedSetSparsityPattern::size_type
-CompressedSetSparsityPattern::bandwidth () const
-{
-  size_type b=0;
-  for (size_type row=0; row<rows; ++row)
-    {
-      for (std::set<size_type>::const_iterator
-           j=lines[row].entries.begin();
-           j != lines[row].entries.end(); ++j)
-        if (static_cast<size_type>(std::abs(static_cast<int>(row-*j))) > b)
-          b = std::abs(static_cast<signed int>(row-*j));
-    }
-
-  return b;
-}
-
-
-
-CompressedSetSparsityPattern::size_type
-CompressedSetSparsityPattern::n_nonzero_elements () const
-{
-  size_type n=0;
-  for (size_type i=0; i<rows; ++i)
-    {
-      n += lines[i].entries.size();
-    }
-
-  return n;
-}
-
-DEAL_II_NAMESPACE_CLOSE
diff --git a/source/lac/compressed_sparsity_pattern.cc b/source/lac/compressed_sparsity_pattern.cc
deleted file mode 100644 (file)
index c43a9a5..0000000
+++ /dev/null
@@ -1,565 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2001 - 2014 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE at
-// the top level of the deal.II distribution.
-//
-// ---------------------------------------------------------------------
-
-#include <deal.II/lac/compressed_sparsity_pattern.h>
-
-#include <iostream>
-#include <iomanip>
-#include <algorithm>
-#include <cmath>
-#include <numeric>
-#include <functional>
-
-DEAL_II_NAMESPACE_OPEN
-
-
-#ifdef DEAL_II_MSVC
-__declspec(selectany)  // weak external binding because of multiple link error
-#endif
-const unsigned int CompressedSparsityPattern::Line::cache_size;
-
-
-
-// This function was originally inlined, because it was called very
-// often without any need, because cache_entries==0. On the other
-// hand, it is very long and causes linker warnings on certain
-// systems.
-
-// Therefore, we require now, that the caller checks if this function
-// is necessary and only calls it, if it is actually used. Since it is
-// called less often, it is removed from the inlined section.
-void
-CompressedSparsityPattern::Line::flush_cache () const
-{
-  // Make sure the caller checked
-  // necessity of this function.
-  Assert(cache_entries != 0, ExcInternalError());
-
-  // first sort the entries in the cache, so
-  // that it is easier to merge it with the
-  // main array. note that due to the way
-  // add() inserts elements, there can be no
-  // duplicates in the cache
-  //
-  // do the sorting in a way that is fast for
-  // the small cache sizes we have
-  // here. basically, use bubble sort
-  switch (cache_entries)
-    {
-    case 1:
-    {
-      break;
-    }
-
-    case 2:
-    {
-      if (cache[1] < cache[0])
-        std::swap (cache[0], cache[1]);
-      break;
-    }
-
-    case 3:
-    {
-      if (cache[1] < cache[0])
-        std::swap (cache[0], cache[1]);
-      if (cache[2] < cache[1])
-        std::swap (cache[1], cache[2]);
-      if (cache[1] < cache[0])
-        std::swap (cache[0], cache[1]);
-      break;
-    }
-
-    case 4:
-    case 5:
-    case 6:
-    case 7:
-    {
-      for (unsigned int i=0; i<cache_entries; ++i)
-        for (unsigned int j=i+1; j<cache_entries; ++j)
-          if (cache[j] < cache[i])
-            std::swap (cache[i], cache[j]);
-      break;
-    }
-
-    default:
-    {
-      std::sort (&cache[0], &cache[cache_entries]);
-      break;
-    }
-    }
-
-  // TODO: could use the add_entries
-  // function of the constraint line for
-  // doing this, but that one is
-  // non-const. Still need to figure out
-  // how to do that.
-
-  // next job is to merge the two
-  // arrays. special case the case that the
-  // original array is empty.
-  if (entries.size() == 0)
-    {
-      entries.resize (cache_entries);
-      for (unsigned int i=0; i<cache_entries; ++i)
-        entries[i] = cache[i];
-    }
-  else
-    {
-      // first count how many of the cache
-      // entries are already in the main
-      // array, so that we can efficiently
-      // allocate memory
-      unsigned int n_new_entries = 0;
-      {
-        unsigned int cache_position = 0;
-        unsigned int entry_position = 0;
-        while ((entry_position<entries.size()) &&
-               (cache_position<cache_entries))
-          {
-            ++n_new_entries;
-            if (entries[entry_position] < cache[cache_position])
-              ++entry_position;
-            else if (entries[entry_position] == cache[cache_position])
-              {
-                ++entry_position;
-                ++cache_position;
-              }
-            else
-              ++cache_position;
-          }
-
-        // scoop up leftovers in arrays
-        n_new_entries += (entries.size() - entry_position) +
-                         (cache_entries - cache_position);
-      }
-
-      // then allocate new memory and merge
-      // arrays, if there are any entries at
-      // all that need to be merged
-      Assert (n_new_entries >= entries.size(),
-              ExcInternalError());
-      if (n_new_entries > entries.size())
-        {
-          std::vector<types::global_dof_index> new_entries;
-          new_entries.reserve (n_new_entries);
-          unsigned int cache_position = 0;
-          unsigned int entry_position = 0;
-          while ((entry_position<entries.size()) &&
-                 (cache_position<cache_entries))
-            if (entries[entry_position] < cache[cache_position])
-              {
-                new_entries.push_back (entries[entry_position]);
-                ++entry_position;
-              }
-            else if (entries[entry_position] == cache[cache_position])
-              {
-                new_entries.push_back (entries[entry_position]);
-                ++entry_position;
-                ++cache_position;
-              }
-            else
-              {
-                new_entries.push_back (cache[cache_position]);
-                ++cache_position;
-              }
-
-          // copy remaining elements from the
-          // array that we haven't
-          // finished. note that at most one
-          // of the following loops will run
-          // at all
-          for (; entry_position < entries.size(); ++entry_position)
-            new_entries.push_back (entries[entry_position]);
-          for (; cache_position < cache_entries; ++cache_position)
-            new_entries.push_back (cache[cache_position]);
-
-          Assert (new_entries.size() == n_new_entries,
-                  ExcInternalError());
-
-          // finally swap old and new array,
-          // and set cache size to zero
-          new_entries.swap (entries);
-        }
-    }
-
-  cache_entries = 0;
-}
-
-
-
-template <typename ForwardIterator>
-void
-CompressedSparsityPattern::Line::add_entries (ForwardIterator begin,
-                                              ForwardIterator end,
-                                              const bool indices_are_sorted)
-{
-  // use the same code as when flushing the
-  // cache in case we have many (more than
-  // three) entries in a sorted
-  // list. Otherwise, go on to the single
-  // add() function.
-  const int n_elements = end - begin;
-  if (n_elements <= 0)
-    return;
-
-  const unsigned int n_cols = static_cast<unsigned int>(n_elements);
-
-  if (indices_are_sorted == true)
-    {
-
-      // next job is to merge the two
-      // arrays. special case the case that the
-      // original array is empty.
-      if (entries.size() == 0)
-        {
-          entries.resize (n_cols);
-          ForwardIterator my_it = begin;
-          for (unsigned int i=0; i<n_cols; ++i)
-            entries[i] = *my_it++;
-        }
-      else
-        {
-          // first count how many of the cache
-          // entries are already in the main
-          // array, so that we can efficiently
-          // allocate memory
-          unsigned int n_new_entries = 0;
-          {
-            unsigned int entry_position = 0;
-            ForwardIterator my_it = begin;
-            while ((entry_position<entries.size()) &&
-                   (my_it != end))
-              {
-                ++n_new_entries;
-                if (entries[entry_position] < *my_it)
-                  ++entry_position;
-                else if (entries[entry_position] == *my_it)
-                  {
-                    ++entry_position;
-                    ++my_it;
-                  }
-                else
-                  ++my_it;
-              }
-
-            // scoop up leftovers in arrays
-            n_new_entries += (entries.size() - entry_position) +
-                             (end - my_it);
-          }
-
-          // then allocate new memory and merge
-          // arrays, if there are any entries at
-          // all that need to be merged
-          Assert (n_new_entries >= entries.size(),
-                  ExcInternalError());
-          if (n_new_entries > entries.size())
-            {
-              std::vector<types::global_dof_index> new_entries;
-              new_entries.reserve (n_new_entries);
-              ForwardIterator my_it = begin;
-              unsigned int entry_position = 0;
-              while ((entry_position<entries.size()) &&
-                     (my_it != end))
-                if (entries[entry_position] < *my_it)
-                  {
-                    new_entries.push_back (entries[entry_position]);
-                    ++entry_position;
-                  }
-                else if (entries[entry_position] == *my_it)
-                  {
-                    new_entries.push_back (entries[entry_position]);
-                    ++entry_position;
-                    ++my_it;
-                  }
-                else
-                  {
-                    new_entries.push_back (*my_it);
-                    ++my_it;
-                  }
-
-              // copy remaining elements from the
-              // array that we haven't
-              // finished. note that at most one
-              // of the following loops will run
-              // at all
-              for (; entry_position < entries.size(); ++entry_position)
-                new_entries.push_back (entries[entry_position]);
-              for (; my_it != end; ++my_it)
-                new_entries.push_back (*my_it);
-
-              Assert (new_entries.size() == n_new_entries,
-                      ExcInternalError());
-
-              // finally swap old and new array,
-              // and set cache size to zero
-              new_entries.swap (entries);
-            }
-        }
-      return;
-    }
-
-  // otherwise, insert the indices one
-  // after each other
-  for (ForwardIterator it = begin; it != end; ++it)
-    add (*it);
-}
-
-
-
-CompressedSparsityPattern::CompressedSparsityPattern ()
-  :
-  rows(0),
-  cols(0)
-{}
-
-
-
-CompressedSparsityPattern::
-CompressedSparsityPattern (const CompressedSparsityPattern &s)
-  :
-  Subscriptor(),
-  rows(0),
-  cols(0)
-{
-  Assert (s.rows == 0, ExcInvalidConstructorCall());
-  Assert (s.cols == 0, ExcInvalidConstructorCall());
-}
-
-
-
-CompressedSparsityPattern::CompressedSparsityPattern (const size_type m,
-                                                      const size_type n)
-  :
-  rows(0),
-  cols(0)
-{
-  reinit (m,n);
-}
-
-
-
-CompressedSparsityPattern::CompressedSparsityPattern (const size_type n)
-  :
-  rows(0),
-  cols(0)
-{
-  reinit (n,n);
-}
-
-
-
-CompressedSparsityPattern &
-CompressedSparsityPattern::operator = (const CompressedSparsityPattern &s)
-{
-  Assert (s.rows == 0, ExcInvalidConstructorCall());
-  Assert (s.cols == 0, ExcInvalidConstructorCall());
-
-  Assert (rows == 0, ExcInvalidConstructorCall());
-  Assert (cols == 0, ExcInvalidConstructorCall());
-
-  return *this;
-}
-
-
-
-void
-CompressedSparsityPattern::reinit (const size_type m,
-                                   const size_type n)
-{
-  rows = m;
-  cols = n;
-
-  std::vector<Line> new_lines (rows);
-  lines.swap (new_lines);
-}
-
-
-
-void
-CompressedSparsityPattern::compress ()
-{}
-
-
-
-bool
-CompressedSparsityPattern::empty () const
-{
-  return ((rows==0) && (cols==0));
-}
-
-
-
-CompressedSparsityPattern::size_type
-CompressedSparsityPattern::max_entries_per_row () const
-{
-  size_type m = 0;
-  for (size_type i=0; i<rows; ++i)
-    {
-      if (lines[i].cache_entries != 0)
-        lines[i].flush_cache ();
-      m = std::max (m, static_cast<size_type>(lines[i].entries.size()));
-    }
-
-  return m;
-}
-
-
-
-bool
-CompressedSparsityPattern::exists (const size_type i,
-                                   const size_type j) const
-{
-  Assert (i<rows, ExcIndexRange(i, 0, rows));
-  Assert (j<cols, ExcIndexRange(j, 0, cols));
-
-  if (lines[i].cache_entries != 0)
-    lines[i].flush_cache();
-  return std::binary_search (lines[i].entries.begin(),
-                             lines[i].entries.end(),
-                             j);
-}
-
-
-
-void
-CompressedSparsityPattern::symmetrize ()
-{
-  Assert (rows==cols, ExcNotQuadratic());
-
-  // loop over all elements presently
-  // in the sparsity pattern and add
-  // the transpose element. note:
-  //
-  // 1. that the sparsity pattern
-  // changes which we work on, but
-  // not the present row
-  //
-  // 2. that the @p{add} function can
-  // be called on elements that
-  // already exist without any harm
-  for (size_type row=0; row<rows; ++row)
-    {
-      if (lines[row].cache_entries != 0)
-        lines[row].flush_cache ();
-      for (std::vector<size_type>::const_iterator
-           j=lines[row].entries.begin();
-           j != lines[row].entries.end();
-           ++j)
-        // add the transpose entry if
-        // this is not the diagonal
-        if (row != *j)
-          add (*j, row);
-    }
-}
-
-
-
-void
-CompressedSparsityPattern::print (std::ostream &out) const
-{
-  for (size_type row=0; row<rows; ++row)
-    {
-      if (lines[row].cache_entries != 0)
-        lines[row].flush_cache ();
-
-      out << '[' << row;
-
-      for (std::vector<size_type>::const_iterator
-           j=lines[row].entries.begin();
-           j != lines[row].entries.end(); ++j)
-        out << ',' << *j;
-
-      out << ']' << std::endl;
-    }
-
-  AssertThrow (out, ExcIO());
-}
-
-
-
-void
-CompressedSparsityPattern::print_gnuplot (std::ostream &out) const
-{
-  for (size_type row=0; row<rows; ++row)
-    {
-      if (lines[row].cache_entries != 0)
-        lines[row].flush_cache ();
-      for (std::vector<size_type>::const_iterator
-           j=lines[row].entries.begin();
-           j != lines[row].entries.end(); ++j)
-        // while matrix entries are usually
-        // written (i,j), with i vertical and
-        // j horizontal, gnuplot output is
-        // x-y, that is we have to exchange
-        // the order of output
-        out << *j << " " << -static_cast<signed int>(row) << std::endl;
-    }
-
-  AssertThrow (out, ExcIO());
-}
-
-
-
-CompressedSparsityPattern::size_type
-CompressedSparsityPattern::bandwidth () const
-{
-  size_type b=0;
-  for (size_type row=0; row<rows; ++row)
-    {
-      if (lines[row].cache_entries != 0)
-        lines[row].flush_cache ();
-
-      for (std::vector<size_type>::const_iterator
-           j=lines[row].entries.begin();
-           j != lines[row].entries.end(); ++j)
-        if (static_cast<size_type>(std::abs(static_cast<int>(row-*j))) > b)
-          b = std::abs(static_cast<signed int>(row-*j));
-    }
-
-  return b;
-}
-
-
-
-CompressedSparsityPattern::size_type
-CompressedSparsityPattern::n_nonzero_elements () const
-{
-  size_type n=0;
-  for (size_type i=0; i<rows; ++i)
-    {
-      if (lines[i].cache_entries != 0)
-        lines[i].flush_cache ();
-      n += lines[i].entries.size();
-    }
-
-  return n;
-}
-
-
-// explicit instantiations
-template void CompressedSparsityPattern::Line::add_entries(size_type *,
-                                                           size_type *,
-                                                           const bool);
-template void CompressedSparsityPattern::Line::add_entries(const size_type *,
-                                                           const size_type *,
-                                                           const bool);
-#ifndef DEAL_II_VECTOR_ITERATOR_IS_POINTER
-template void CompressedSparsityPattern::Line::
-add_entries(std::vector<size_type>::iterator,
-            std::vector<size_type>::iterator,
-            const bool);
-#endif
-
-DEAL_II_NAMESPACE_CLOSE
index a8d149398f9571b3de71469f167e5d9bde476cce..3da83d75d1846b45171505681618272744a49874 100644 (file)
@@ -17,9 +17,7 @@
 #include <deal.II/lac/constraint_matrix.templates.h>
 
 #include <deal.II/base/memory_consumption.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
-#include <deal.II/lac/compressed_set_sparsity_pattern.h>
-#include <deal.II/lac/compressed_simple_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/block_vector.h>
 #include <deal.II/lac/block_sparse_matrix.h>
 #include <deal.II/lac/sparse_matrix_ez.h>
@@ -724,174 +722,8 @@ void ConstraintMatrix::condense (SparsityPattern &sparsity) const
 
 
 
-void ConstraintMatrix::condense (CompressedSparsityPattern &sparsity) const
-{
-  Assert (sorted == true, ExcMatrixNotClosed());
-  Assert (sparsity.n_rows() == sparsity.n_cols(),
-          ExcNotQuadratic());
-
-  // store for each index whether it must be distributed or not. If entry
-  // is numbers::invalid_unsigned_int, no distribution is necessary.
-  // otherwise, the number states which line in the constraint matrix
-  // handles this index
-  std::vector<size_type> distribute(sparsity.n_rows(),
-                                    numbers::invalid_size_type);
-
-  for (size_type c=0; c<lines.size(); ++c)
-    distribute[lines[c].line] = c;
-
-  const size_type n_rows = sparsity.n_rows();
-  for (size_type row=0; row<n_rows; ++row)
-    {
-      if (distribute[row] == numbers::invalid_size_type)
-        // regular line. loop over cols. note that as we proceed to
-        // distribute cols, the loop may get longer
-        for (size_type j=0; j<sparsity.row_length(row); ++j)
-          {
-            const size_type column = sparsity.column_number(row,j);
-
-            if (distribute[column] != numbers::invalid_size_type)
-              {
-                // distribute entry at regular row @p{row} and irregular
-                // column column. note that this changes the line we are
-                // presently working on: we add additional entries. if we
-                // add another entry at a column behind the present one, we
-                // will encounter it later on (but since it can't be
-                // further constrained, won't have to do anything about
-                // it). if we add it up front of the present column, we
-                // will find the present column later on again as it was
-                // shifted back (again nothing happens, in particular no
-                // endless loop, as when we encounter it the second time we
-                // won't be able to add more entries as they all already
-                // exist, but we do the same work more often than
-                // necessary, and the loop gets longer), so move the cursor
-                // one to the right in the case that we add an entry up
-                // front that did not exist before. check whether it
-                // existed before by tracking the length of this row
-                size_type old_rowlength = sparsity.row_length(row);
-                for (size_type q=0;
-                     q!=lines[distribute[column]].entries.size();
-                     ++q)
-                  {
-                    const size_type
-                    new_col = lines[distribute[column]].entries[q].first;
-
-                    sparsity.add (row, new_col);
 
-                    const size_type new_rowlength = sparsity.row_length(row);
-                    if ((new_col < column) && (old_rowlength != new_rowlength))
-                      ++j;
-                    old_rowlength = new_rowlength;
-                  };
-              };
-          }
-      else
-        // row must be distributed
-        for (size_type j=0; j<sparsity.row_length(row); ++j)
-          {
-            const size_type column = sparsity.column_number(row,j);
-
-            if (distribute[column] == numbers::invalid_size_type)
-              // distribute entry at irregular row @p{row} and regular
-              // column sparsity.colnums[j]
-              for (size_type q=0;
-                   q!=lines[distribute[row]].entries.size(); ++q)
-                sparsity.add (lines[distribute[row]].entries[q].first,
-                              column);
-            else
-              // distribute entry at irregular row @p{row} and irregular
-              // column sparsity.get_column_numbers()[j]
-              for (size_type p=0; p!=lines[distribute[row]].entries.size(); ++p)
-                for (size_type q=0;
-                     q!=lines[distribute[sparsity.column_number(row,j)]]
-                     .entries.size(); ++q)
-                  sparsity.add (lines[distribute[row]].entries[p].first,
-                                lines[distribute[sparsity.column_number(row,j)]]
-                                .entries[q].first);
-          };
-    };
-}
-
-
-
-void ConstraintMatrix::condense (CompressedSetSparsityPattern &sparsity) const
-{
-  Assert (sorted == true, ExcMatrixNotClosed());
-  Assert (sparsity.n_rows() == sparsity.n_cols(),
-          ExcNotQuadratic());
-
-  // store for each index whether it must be distributed or not. If entry
-  // is numbers::invalid_unsigned_int, no distribution is necessary.
-  // otherwise, the number states which line in the constraint matrix
-  // handles this index
-  std::vector<size_type> distribute(sparsity.n_rows(),
-                                    numbers::invalid_size_type);
-
-  for (size_type c=0; c<lines.size(); ++c)
-    distribute[lines[c].line] = c;
-
-  const size_type n_rows = sparsity.n_rows();
-  for (size_type row=0; row<n_rows; ++row)
-    {
-      if (distribute[row] == numbers::invalid_size_type)
-        {
-          // regular line. loop over cols. note that as we proceed to
-          // distribute cols, the loop may get longer
-          CompressedSetSparsityPattern::row_iterator col_num = sparsity.row_begin (row);
-
-          for (; col_num != sparsity.row_end (row); ++col_num)
-            {
-              const size_type column = *col_num;
-
-              if (distribute[column] != numbers::invalid_size_type)
-                {
-                  // row
-                  for (size_type q=0;
-                       q!=lines[distribute[column]].entries.size();
-                       ++q)
-                    {
-                      const size_type
-                      new_col = lines[distribute[column]].entries[q].first;
-
-                      sparsity.add (row, new_col);
-                    }
-                }
-            }
-        }
-      else
-        // row must be distributed
-        {
-          CompressedSetSparsityPattern::row_iterator col_num = sparsity.row_begin (row);
-
-          for (; col_num != sparsity.row_end (row); ++col_num)
-            {
-              const size_type column = *col_num;
-
-              if (distribute[column] == numbers::invalid_size_type)
-                // distribute entry at irregular row @p{row} and regular
-                // column sparsity.colnums[j]
-                for (size_type q=0;
-                     q!=lines[distribute[row]].entries.size(); ++q)
-                  sparsity.add (lines[distribute[row]].entries[q].first,
-                                column);
-              else
-                // distribute entry at irregular row @p{row} and irregular
-                // column sparsity.get_column_numbers()[j]
-                for (size_type p=0; p!=lines[distribute[row]].entries.size(); ++p)
-                  for (size_type q=0;
-                       q!=lines[distribute[column]]
-                       .entries.size(); ++q)
-                    sparsity.add (lines[distribute[row]].entries[p].first,
-                                  lines[distribute[column]]
-                                  .entries[q].first);
-            };
-        }
-    };
-}
-
-
-
-void ConstraintMatrix::condense (CompressedSimpleSparsityPattern &sparsity) const
+void ConstraintMatrix::condense (DynamicSparsityPattern &sparsity) const
 {
   Assert (sorted == true, ExcMatrixNotClosed());
   Assert (sparsity.n_rows() == sparsity.n_cols(),
@@ -1092,231 +924,8 @@ void ConstraintMatrix::condense (BlockSparsityPattern &sparsity) const
 
 
 
-void ConstraintMatrix::condense (BlockCompressedSparsityPattern &sparsity) const
-{
-  Assert (sorted == true, ExcMatrixNotClosed());
-  Assert (sparsity.n_rows() == sparsity.n_cols(),
-          ExcNotQuadratic());
-  Assert (sparsity.n_block_rows() == sparsity.n_block_cols(),
-          ExcNotQuadratic());
-  Assert (sparsity.get_column_indices() == sparsity.get_row_indices(),
-          ExcNotQuadratic());
-
-  const BlockIndices &
-  index_mapping = sparsity.get_column_indices();
-
-  const size_type n_blocks = sparsity.n_block_rows();
-
-  // store for each index whether it must be distributed or not. If entry
-  // is numbers::invalid_unsigned_int, no distribution is necessary.
-  // otherwise, the number states which line in the constraint matrix
-  // handles this index
-  std::vector<size_type> distribute (sparsity.n_rows(),
-                                     numbers::invalid_size_type);
-
-  for (size_type c=0; c<lines.size(); ++c)
-    distribute[lines[c].line] = static_cast<signed int>(c);
-
-  const size_type n_rows = sparsity.n_rows();
-  for (size_type row=0; row<n_rows; ++row)
-    {
-      // get index of this row within the blocks
-      const std::pair<size_type,size_type>
-      block_index = index_mapping.global_to_local(row);
-      const size_type block_row = block_index.first;
-      const size_type local_row = block_index.second;
-
-      if (distribute[row] == numbers::invalid_size_type)
-        // regular line. loop over all columns and see whether this column
-        // must be distributed. note that as we proceed to distribute cols,
-        // the loop over cols may get longer.
-        //
-        // don't try to be clever here as in the algorithm for the
-        // CompressedSparsityPattern, as that would be much more
-        // complicated here. after all, we know that compressed patterns
-        // are inefficient...
-        {
-
-          // to loop over all entries in this row, we have to loop over all
-          // blocks in this blockrow and the corresponding row therein
-          for (size_type block_col=0; block_col<n_blocks; ++block_col)
-            {
-              const CompressedSparsityPattern &
-              block_sparsity = sparsity.block(block_row, block_col);
-
-              for (size_type j=0; j<block_sparsity.row_length(local_row); ++j)
-                {
-                  const size_type global_col
-                    = index_mapping.local_to_global(block_col,
-                                                    block_sparsity.column_number(local_row,j));
-
-                  if (distribute[global_col] != numbers::invalid_size_type)
-                    // distribute entry at regular row @p{row} and
-                    // irregular column global_col
-                    {
-                      for (size_type q=0;
-                           q!=lines[distribute[global_col]]
-                           .entries.size(); ++q)
-                        sparsity.add (row,
-                                      lines[distribute[global_col]].entries[q].first);
-                    };
-                };
-            };
-        }
-      else
-        {
-          // row must be distributed. split the whole row into the chunks
-          // defined by the blocks
-          for (size_type block_col=0; block_col<n_blocks; ++block_col)
-            {
-              const CompressedSparsityPattern &
-              block_sparsity = sparsity.block(block_row,block_col);
-
-              for (size_type j=0; j<block_sparsity.row_length(local_row); ++j)
-                {
-                  const size_type global_col
-                    = index_mapping.local_to_global (block_col,
-                                                     block_sparsity.column_number(local_row,j));
-
-                  if (distribute[global_col] == numbers::invalid_size_type)
-                    // distribute entry at irregular row @p{row} and
-                    // regular column global_col.
-                    {
-                      for (size_type q=0; q!=lines[distribute[row]].entries.size(); ++q)
-                        sparsity.add (lines[distribute[row]].entries[q].first,
-                                      global_col);
-                    }
-                  else
-                    // distribute entry at irregular row @p{row} and
-                    // irregular column @p{global_col}
-                    {
-                      for (size_type p=0; p!=lines[distribute[row]].entries.size(); ++p)
-                        for (size_type q=0; q!=lines[distribute[global_col]].entries.size(); ++q)
-                          sparsity.add (lines[distribute[row]].entries[p].first,
-                                        lines[distribute[global_col]].entries[q].first);
-                    };
-                };
-            };
-        };
-    };
-}
-
-
-
-void ConstraintMatrix::condense (BlockCompressedSetSparsityPattern &sparsity) const
-{
-  Assert (sorted == true, ExcMatrixNotClosed());
-  Assert (sparsity.n_rows() == sparsity.n_cols(),
-          ExcNotQuadratic());
-  Assert (sparsity.n_block_rows() == sparsity.n_block_cols(),
-          ExcNotQuadratic());
-  Assert (sparsity.get_column_indices() == sparsity.get_row_indices(),
-          ExcNotQuadratic());
-
-  const BlockIndices &
-  index_mapping = sparsity.get_column_indices();
-
-  const size_type n_blocks = sparsity.n_block_rows();
-
-  // store for each index whether it must be distributed or not. If entry
-  // is numbers::invalid_unsigned_int, no distribution is necessary.
-  // otherwise, the number states which line in the constraint matrix
-  // handles this index
-  std::vector<size_type> distribute (sparsity.n_rows(),
-                                     numbers::invalid_size_type);
-
-  for (size_type c=0; c<lines.size(); ++c)
-    distribute[lines[c].line] = static_cast<signed int>(c);
-
-  const size_type n_rows = sparsity.n_rows();
-  for (size_type row=0; row<n_rows; ++row)
-    {
-      // get index of this row within the blocks
-      const std::pair<size_type,size_type>
-      block_index = index_mapping.global_to_local(row);
-      const size_type block_row = block_index.first;
-      const size_type local_row = block_index.second;
-
-      if (distribute[row] == numbers::invalid_size_type)
-        // regular line. loop over all columns and see whether this column
-        // must be distributed. note that as we proceed to distribute cols,
-        // the loop over cols may get longer.
-        //
-        // don't try to be clever here as in the algorithm for the
-        // CompressedSparsityPattern, as that would be much more
-        // complicated here. after all, we know that compressed patterns
-        // are inefficient...
-        {
-
-          // to loop over all entries in this row, we have to loop over all
-          // blocks in this blockrow and the corresponding row therein
-          for (size_type block_col=0; block_col<n_blocks; ++block_col)
-            {
-              const CompressedSetSparsityPattern &
-              block_sparsity = sparsity.block(block_row, block_col);
-
-              for (CompressedSetSparsityPattern::row_iterator
-                   j = block_sparsity.row_begin(local_row);
-                   j != block_sparsity.row_end(local_row); ++j)
-                {
-                  const size_type global_col
-                    = index_mapping.local_to_global(block_col, *j);
-
-                  if (distribute[global_col] != numbers::invalid_size_type)
-                    // distribute entry at regular row @p{row} and
-                    // irregular column global_col
-                    {
-                      for (size_type q=0;
-                           q!=lines[distribute[global_col]]
-                           .entries.size(); ++q)
-                        sparsity.add (row,
-                                      lines[distribute[global_col]].entries[q].first);
-                    };
-                };
-            };
-        }
-      else
-        {
-          // row must be distributed. split the whole row into the chunks
-          // defined by the blocks
-          for (size_type block_col=0; block_col<n_blocks; ++block_col)
-            {
-              const CompressedSetSparsityPattern &
-              block_sparsity = sparsity.block(block_row,block_col);
-
-              for (CompressedSetSparsityPattern::row_iterator
-                   j = block_sparsity.row_begin(local_row);
-                   j != block_sparsity.row_end(local_row); ++j)
-                {
-                  const size_type global_col
-                    = index_mapping.local_to_global (block_col, *j);
-
-                  if (distribute[global_col] == numbers::invalid_size_type)
-                    // distribute entry at irregular row @p{row} and
-                    // regular column global_col.
-                    {
-                      for (size_type q=0; q!=lines[distribute[row]].entries.size(); ++q)
-                        sparsity.add (lines[distribute[row]].entries[q].first,
-                                      global_col);
-                    }
-                  else
-                    // distribute entry at irregular row @p{row} and
-                    // irregular column @p{global_col}
-                    {
-                      for (size_type p=0; p!=lines[distribute[row]].entries.size(); ++p)
-                        for (size_type q=0; q!=lines[distribute[global_col]].entries.size(); ++q)
-                          sparsity.add (lines[distribute[row]].entries[p].first,
-                                        lines[distribute[global_col]].entries[q].first);
-                    };
-                };
-            };
-        };
-    };
-}
-
-
 
-void ConstraintMatrix::condense (BlockCompressedSimpleSparsityPattern &sparsity) const
+void ConstraintMatrix::condense (BlockDynamicSparsityPattern &sparsity) const
 {
   Assert (sorted == true, ExcMatrixNotClosed());
   Assert (sparsity.n_rows() == sparsity.n_cols(),
@@ -1365,7 +974,7 @@ void ConstraintMatrix::condense (BlockCompressedSimpleSparsityPattern &sparsity)
           // blocks in this blockrow and the corresponding row therein
           for (size_type block_col=0; block_col<n_blocks; ++block_col)
             {
-              const CompressedSimpleSparsityPattern &
+              const DynamicSparsityPattern &
               block_sparsity = sparsity.block(block_row, block_col);
 
               for (size_type j=0; j<block_sparsity.row_length(local_row); ++j)
@@ -1393,7 +1002,7 @@ void ConstraintMatrix::condense (BlockCompressedSimpleSparsityPattern &sparsity)
           // defined by the blocks
           for (size_type block_col=0; block_col<n_blocks; ++block_col)
             {
-              const CompressedSimpleSparsityPattern &
+              const DynamicSparsityPattern &
               block_sparsity = sparsity.block(block_row,block_col);
 
               for (size_type j=0; j<block_sparsity.row_length(local_row); ++j)
@@ -1744,13 +1353,9 @@ BLOCK_MATRIX_VECTOR_FUNCTIONS(TrilinosWrappers::BlockSparseMatrix, TrilinosWrapp
       const Table<2,bool> &) const
 
 SPARSITY_FUNCTIONS(SparsityPattern);
-SPARSITY_FUNCTIONS(CompressedSparsityPattern);
-SPARSITY_FUNCTIONS(CompressedSetSparsityPattern);
-SPARSITY_FUNCTIONS(CompressedSimpleSparsityPattern);
+SPARSITY_FUNCTIONS(DynamicSparsityPattern);
 BLOCK_SPARSITY_FUNCTIONS(BlockSparsityPattern);
-BLOCK_SPARSITY_FUNCTIONS(BlockCompressedSparsityPattern);
-BLOCK_SPARSITY_FUNCTIONS(BlockCompressedSetSparsityPattern);
-BLOCK_SPARSITY_FUNCTIONS(BlockCompressedSimpleSparsityPattern);
+BLOCK_SPARSITY_FUNCTIONS(BlockDynamicSparsityPattern);
 
 #ifdef DEAL_II_WITH_TRILINOS
 SPARSITY_FUNCTIONS(TrilinosWrappers::SparsityPattern);
similarity index 80%
rename from source/lac/compressed_simple_sparsity_pattern.cc
rename to source/lac/dynamic_sparsity_pattern.cc
index 0d2e9723520e685a93903dd990dba918a839c516..e43f56c585935fea5f63bd0f6ab5fae741e9d11f 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2008 - 2014 by the deal.II authors
+// Copyright (C) 2008 - 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -13,7 +13,7 @@
 //
 // ---------------------------------------------------------------------
 
-#include <deal.II/lac/compressed_simple_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/base/memory_consumption.h>
 
 #include <algorithm>
@@ -27,9 +27,9 @@ DEAL_II_NAMESPACE_OPEN
 
 template <typename ForwardIterator>
 void
-CompressedSimpleSparsityPattern::Line::add_entries (ForwardIterator begin,
-                                                    ForwardIterator end,
-                                                    const bool      indices_are_sorted)
+DynamicSparsityPattern::Line::add_entries (ForwardIterator begin,
+                                           ForwardIterator end,
+                                           const bool      indices_are_sorted)
 {
   const int n_elements = end - begin;
   if (n_elements <= 0)
@@ -207,14 +207,14 @@ CompressedSimpleSparsityPattern::Line::add_entries (ForwardIterator begin,
 }
 
 
-CompressedSimpleSparsityPattern::size_type
-CompressedSimpleSparsityPattern::Line::memory_consumption () const
+DynamicSparsityPattern::size_type
+DynamicSparsityPattern::Line::memory_consumption () const
 {
   return entries.capacity()*sizeof(size_type)+sizeof(Line);
 }
 
 
-CompressedSimpleSparsityPattern::CompressedSimpleSparsityPattern ()
+DynamicSparsityPattern::DynamicSparsityPattern ()
   :
   rows(0),
   cols(0),
@@ -223,8 +223,8 @@ CompressedSimpleSparsityPattern::CompressedSimpleSparsityPattern ()
 
 
 
-CompressedSimpleSparsityPattern::
-CompressedSimpleSparsityPattern (const CompressedSimpleSparsityPattern &s)
+DynamicSparsityPattern::
+DynamicSparsityPattern (const DynamicSparsityPattern &s)
   :
   Subscriptor(),
   rows(0),
@@ -237,10 +237,10 @@ CompressedSimpleSparsityPattern (const CompressedSimpleSparsityPattern &s)
 
 
 
-CompressedSimpleSparsityPattern::CompressedSimpleSparsityPattern (const size_type m,
-    const size_type n,
-    const IndexSet &rowset_
-                                                                 )
+DynamicSparsityPattern::DynamicSparsityPattern (const size_type m,
+                                                const size_type n,
+                                                const IndexSet &rowset_
+                                               )
   :
   rows(0),
   cols(0),
@@ -250,7 +250,7 @@ CompressedSimpleSparsityPattern::CompressedSimpleSparsityPattern (const size_typ
 }
 
 
-CompressedSimpleSparsityPattern::CompressedSimpleSparsityPattern (const IndexSet &rowset_)
+DynamicSparsityPattern::DynamicSparsityPattern (const IndexSet &rowset_)
   :
   rows(0),
   cols(0),
@@ -260,7 +260,7 @@ CompressedSimpleSparsityPattern::CompressedSimpleSparsityPattern (const IndexSet
 }
 
 
-CompressedSimpleSparsityPattern::CompressedSimpleSparsityPattern (const size_type n)
+DynamicSparsityPattern::DynamicSparsityPattern (const size_type n)
   :
   rows(0),
   cols(0),
@@ -271,8 +271,8 @@ CompressedSimpleSparsityPattern::CompressedSimpleSparsityPattern (const size_typ
 
 
 
-CompressedSimpleSparsityPattern &
-CompressedSimpleSparsityPattern::operator = (const CompressedSimpleSparsityPattern &s)
+DynamicSparsityPattern &
+DynamicSparsityPattern::operator = (const DynamicSparsityPattern &s)
 {
   Assert (s.rows == 0, ExcInvalidConstructorCall());
   Assert (s.cols == 0, ExcInvalidConstructorCall());
@@ -286,9 +286,9 @@ CompressedSimpleSparsityPattern::operator = (const CompressedSimpleSparsityPatte
 
 
 void
-CompressedSimpleSparsityPattern::reinit (const size_type m,
-                                         const size_type n,
-                                         const IndexSet &rowset_)
+DynamicSparsityPattern::reinit (const size_type m,
+                                const size_type n,
+                                const IndexSet &rowset_)
 {
   rows = m;
   cols = n;
@@ -303,21 +303,21 @@ CompressedSimpleSparsityPattern::reinit (const size_type m,
 
 
 void
-CompressedSimpleSparsityPattern::compress ()
+DynamicSparsityPattern::compress ()
 {}
 
 
 
 bool
-CompressedSimpleSparsityPattern::empty () const
+DynamicSparsityPattern::empty () const
 {
   return ((rows==0) && (cols==0));
 }
 
 
 
-CompressedSimpleSparsityPattern::size_type
-CompressedSimpleSparsityPattern::max_entries_per_row () const
+DynamicSparsityPattern::size_type
+DynamicSparsityPattern::max_entries_per_row () const
 {
   size_type m = 0;
   for (size_type i=0; i<lines.size(); ++i)
@@ -331,8 +331,8 @@ CompressedSimpleSparsityPattern::max_entries_per_row () const
 
 
 bool
-CompressedSimpleSparsityPattern::exists (const size_type i,
-                                         const size_type j) const
+DynamicSparsityPattern::exists (const size_type i,
+                                const size_type j) const
 {
   Assert (i<rows, ExcIndexRange(i, 0, rows));
   Assert (j<cols, ExcIndexRange(j, 0, cols));
@@ -349,7 +349,7 @@ CompressedSimpleSparsityPattern::exists (const size_type i,
 
 
 void
-CompressedSimpleSparsityPattern::symmetrize ()
+DynamicSparsityPattern::symmetrize ()
 {
   Assert (rows==cols, ExcNotQuadratic());
 
@@ -383,7 +383,7 @@ CompressedSimpleSparsityPattern::symmetrize ()
 
 
 void
-CompressedSimpleSparsityPattern::print (std::ostream &out) const
+DynamicSparsityPattern::print (std::ostream &out) const
 {
   for (size_type row=0; row<lines.size(); ++row)
     {
@@ -403,7 +403,7 @@ CompressedSimpleSparsityPattern::print (std::ostream &out) const
 
 
 void
-CompressedSimpleSparsityPattern::print_gnuplot (std::ostream &out) const
+DynamicSparsityPattern::print_gnuplot (std::ostream &out) const
 {
   for (size_type row=0; row<lines.size(); ++row)
     {
@@ -429,8 +429,8 @@ CompressedSimpleSparsityPattern::print_gnuplot (std::ostream &out) const
 
 
 
-CompressedSimpleSparsityPattern::size_type
-CompressedSimpleSparsityPattern::bandwidth () const
+DynamicSparsityPattern::size_type
+DynamicSparsityPattern::bandwidth () const
 {
   size_type b=0;
   for (size_type row=0; row<lines.size(); ++row)
@@ -450,8 +450,8 @@ CompressedSimpleSparsityPattern::bandwidth () const
 
 
 
-CompressedSimpleSparsityPattern::size_type
-CompressedSimpleSparsityPattern::n_nonzero_elements () const
+DynamicSparsityPattern::size_type
+DynamicSparsityPattern::n_nonzero_elements () const
 {
   size_type n=0;
   for (size_type i=0; i<lines.size(); ++i)
@@ -463,11 +463,11 @@ CompressedSimpleSparsityPattern::n_nonzero_elements () const
 }
 
 
-CompressedSimpleSparsityPattern::size_type
-CompressedSimpleSparsityPattern::memory_consumption () const
+DynamicSparsityPattern::size_type
+DynamicSparsityPattern::memory_consumption () const
 {
   //TODO: IndexSet...
-  size_type mem = sizeof(CompressedSimpleSparsityPattern);
+  size_type mem = sizeof(DynamicSparsityPattern);
   for (size_type i=0; i<lines.size(); ++i)
     mem += MemoryConsumption::memory_consumption (lines[i]);
 
@@ -476,14 +476,14 @@ CompressedSimpleSparsityPattern::memory_consumption () const
 
 
 // explicit instantiations
-template void CompressedSimpleSparsityPattern::Line::add_entries(size_type *,
-    size_type *,
-    const bool);
-template void CompressedSimpleSparsityPattern::Line::add_entries(const size_type *,
-    const size_type *,
-    const bool);
+template void DynamicSparsityPattern::Line::add_entries(size_type *,
+                                                        size_type *,
+                                                        const bool);
+template void DynamicSparsityPattern::Line::add_entries(const size_type *,
+                                                        const size_type *,
+                                                        const bool);
 #ifndef DEAL_II_VECTOR_ITERATOR_IS_POINTER
-template void CompressedSimpleSparsityPattern::Line::
+template void DynamicSparsityPattern::Line::
 add_entries(std::vector<size_type>::iterator,
             std::vector<size_type>::iterator,
             const bool);
index 2aaaf4b0e980d6962ca19ae88ebaa25862aafae7..011f6ecce7827bb7d2a522560ea506ca75fdce7e 100644 (file)
@@ -71,7 +71,7 @@ namespace PETScWrappers
     BlockSparseMatrix::
     reinit(const std::vector<IndexSet> &rows,
            const std::vector<IndexSet> &cols,
-           const BlockCompressedSimpleSparsityPattern &bcsp,
+           const BlockDynamicSparsityPattern &bcsp,
            const MPI_Comm &com)
     {
       Assert(rows.size() == bcsp.n_block_rows(), ExcMessage("invalid size"));
@@ -112,7 +112,7 @@ namespace PETScWrappers
     void
     BlockSparseMatrix::
     reinit(const std::vector<IndexSet> &sizes,
-           const BlockCompressedSimpleSparsityPattern &bcsp,
+           const BlockDynamicSparsityPattern &bcsp,
            const MPI_Comm &com)
     {
       reinit(sizes, sizes, bcsp, com);
index 0232e5a14362faed39ffb39e18e96c959474137f..7e4c3c7c7b67d397596d33078fc08387e5645ae6 100644 (file)
@@ -19,8 +19,7 @@
 
 #  include <deal.II/lac/petsc_vector.h>
 #  include <deal.II/lac/sparsity_pattern.h>
-#  include <deal.II/lac/compressed_sparsity_pattern.h>
-#  include <deal.II/lac/compressed_simple_sparsity_pattern.h>
+#  include <deal.II/lac/dynamic_sparsity_pattern.h>
 
 DEAL_II_NAMESPACE_OPEN
 
@@ -818,14 +817,7 @@ namespace PETScWrappers
                                 const bool);
     template
     SparseMatrix::SparseMatrix (const MPI_Comm &,
-                                const CompressedSparsityPattern &,
-                                const std::vector<size_type> &,
-                                const std::vector<size_type> &,
-                                const unsigned int,
-                                const bool);
-    template
-    SparseMatrix::SparseMatrix (const MPI_Comm &,
-                                const CompressedSimpleSparsityPattern &,
+                                const DynamicSparsityPattern &,
                                 const std::vector<size_type> &,
                                 const std::vector<size_type> &,
                                 const unsigned int,
@@ -840,14 +832,7 @@ namespace PETScWrappers
                           const bool);
     template void
     SparseMatrix::reinit (const MPI_Comm &,
-                          const CompressedSparsityPattern &,
-                          const std::vector<size_type> &,
-                          const std::vector<size_type> &,
-                          const unsigned int,
-                          const bool);
-    template void
-    SparseMatrix::reinit (const MPI_Comm &,
-                          const CompressedSimpleSparsityPattern &,
+                          const DynamicSparsityPattern &,
                           const std::vector<size_type> &,
                           const std::vector<size_type> &,
                           const unsigned int,
@@ -857,7 +842,7 @@ namespace PETScWrappers
     SparseMatrix::
     reinit (const IndexSet &,
             const IndexSet &,
-            const CompressedSimpleSparsityPattern &,
+            const DynamicSparsityPattern &,
             const MPI_Comm &);
 
     template void
@@ -867,13 +852,7 @@ namespace PETScWrappers
                              const unsigned int ,
                              const bool);
     template void
-    SparseMatrix::do_reinit (const CompressedSparsityPattern &,
-                             const std::vector<size_type> &,
-                             const std::vector<size_type> &,
-                             const unsigned int ,
-                             const bool);
-    template void
-    SparseMatrix::do_reinit (const CompressedSimpleSparsityPattern &,
+    SparseMatrix::do_reinit (const DynamicSparsityPattern &,
                              const std::vector<size_type> &,
                              const std::vector<size_type> &,
                              const unsigned int ,
@@ -883,7 +862,7 @@ namespace PETScWrappers
     SparseMatrix::
     do_reinit (const IndexSet &,
                const IndexSet &,
-               const CompressedSimpleSparsityPattern &);
+               const DynamicSparsityPattern &);
 
 
     PetscScalar
index 2835a27b46b67dd586602002f1830db47f1202d6..9675843e7d14d300c987511af5a0118b91179ce3 100644 (file)
@@ -19,8 +19,7 @@
 
 #  include <deal.II/lac/petsc_vector.h>
 #  include <deal.II/lac/sparsity_pattern.h>
-#  include <deal.II/lac/compressed_sparsity_pattern.h>
-#  include <deal.II/lac/compressed_simple_sparsity_pattern.h>
+#  include <deal.II/lac/dynamic_sparsity_pattern.h>
 
 DEAL_II_NAMESPACE_OPEN
 
@@ -316,30 +315,21 @@ namespace PETScWrappers
   SparseMatrix::SparseMatrix (const SparsityPattern &,
                               const bool);
   template
-  SparseMatrix::SparseMatrix (const CompressedSparsityPattern &,
-                              const bool);
-  template
-  SparseMatrix::SparseMatrix (const CompressedSimpleSparsityPattern &,
+  SparseMatrix::SparseMatrix (const DynamicSparsityPattern &,
                               const bool);
 
   template void
   SparseMatrix::reinit (const SparsityPattern &,
                         const bool);
   template void
-  SparseMatrix::reinit (const CompressedSparsityPattern &,
-                        const bool);
-  template void
-  SparseMatrix::reinit (const CompressedSimpleSparsityPattern &,
+  SparseMatrix::reinit (const DynamicSparsityPattern &,
                         const bool);
 
   template void
   SparseMatrix::do_reinit (const SparsityPattern &,
                            const bool);
   template void
-  SparseMatrix::do_reinit (const CompressedSparsityPattern &,
-                           const bool);
-  template void
-  SparseMatrix::do_reinit (const CompressedSimpleSparsityPattern &,
+  SparseMatrix::do_reinit (const DynamicSparsityPattern &,
                            const bool);
 
   PetscScalar
index f854bc0e741849c1e884d31ea6b293b576a0fd17..e7ac065ee66bce5024dc843c49842e2395c1b91f 100644 (file)
@@ -19,9 +19,7 @@
 #include <deal.II/lac/sparsity_pattern.h>
 #include <deal.II/lac/sparsity_tools.h>
 #include <deal.II/lac/full_matrix.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
-#include <deal.II/lac/compressed_set_sparsity_pattern.h>
-#include <deal.II/lac/compressed_simple_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 
 #include <iostream>
 #include <iomanip>
@@ -966,9 +964,7 @@ SparsityPattern::memory_consumption () const
 
 // explicit instantiations
 template void SparsityPattern::copy_from<SparsityPattern> (const SparsityPattern &);
-template void SparsityPattern::copy_from<CompressedSparsityPattern> (const CompressedSparsityPattern &);
-template void SparsityPattern::copy_from<CompressedSetSparsityPattern> (const CompressedSetSparsityPattern &);
-template void SparsityPattern::copy_from<CompressedSimpleSparsityPattern> (const CompressedSimpleSparsityPattern &);
+template void SparsityPattern::copy_from<DynamicSparsityPattern> (const DynamicSparsityPattern &);
 template void SparsityPattern::copy_from<float> (const FullMatrix<float> &);
 template void SparsityPattern::copy_from<double> (const FullMatrix<double> &);
 
index 3a158a27edc1829ddaf00ae7fc41547f880ae09c..492ee1589c8825782b8a3fdb9a471eee4754a0c7 100644 (file)
@@ -24,9 +24,7 @@
 
 #ifdef DEAL_II_WITH_MPI
 #include <deal.II/base/utilities.h>
-#include <deal.II/lac/compressed_sparsity_pattern.h>
-#include <deal.II/lac/compressed_set_sparsity_pattern.h>
-#include <deal.II/lac/compressed_simple_sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/block_sparsity_pattern.h>
 #endif
 
@@ -642,8 +640,7 @@ namespace SparsityTools
       const IndexSet & myrange)
 
 #ifdef DEAL_II_WITH_MPI
-SPARSITY_FUNCTIONS(CompressedSparsityPattern);
-SPARSITY_FUNCTIONS(CompressedSimpleSparsityPattern);
+SPARSITY_FUNCTIONS(DynamicSparsityPattern);
 
 template void SparsityTools::distribute_sparsity_pattern
 <BlockCompressedSimpleSparsityPattern>
index 8366cee339212f7b7f952d69a76ff9e152cd64c3..f5743f70ab7a69fd23efa9326c0e3949c4177c78 100644 (file)
@@ -386,12 +386,7 @@ namespace TrilinosWrappers
   template void
   BlockSparseMatrix::reinit (const dealii::BlockSparsityPattern &);
   template void
-  BlockSparseMatrix::reinit (const dealii::BlockCompressedSparsityPattern &);
-  template void
-  BlockSparseMatrix::reinit (const dealii::BlockCompressedSetSparsityPattern &);
-  template void
-  BlockSparseMatrix::reinit (const dealii::BlockCompressedSimpleSparsityPattern &);
-
+  BlockSparseMatrix::reinit (const dealii::BlockDynamicSparsityPattern &);
 
   template void
   BlockSparseMatrix::reinit (const std::vector<Epetra_Map> &,
@@ -399,20 +394,12 @@ namespace TrilinosWrappers
                              const bool);
   template void
   BlockSparseMatrix::reinit (const std::vector<Epetra_Map> &,
-                             const dealii::BlockCompressedSparsityPattern &,
-                             const bool);
-  template void
-  BlockSparseMatrix::reinit (const std::vector<Epetra_Map> &,
-                             const dealii::BlockCompressedSetSparsityPattern &,
-                             const bool);
-  template void
-  BlockSparseMatrix::reinit (const std::vector<Epetra_Map> &,
-                             const dealii::BlockCompressedSimpleSparsityPattern &,
+                             const dealii::BlockDynamicSparsityPattern &,
                              const bool);
 
   template void
   BlockSparseMatrix::reinit (const std::vector<IndexSet> &,
-                             const dealii::BlockCompressedSimpleSparsityPattern &,
+                             const dealii::BlockDynamicSparsityPattern &,
                              const MPI_Comm &,
                              const bool);
 
index 2c464c1ead2ddbe98a9820dee818526828d8e9e4..d956100edc8f7ddf7751f276cf2d11d9732a6014 100644 (file)
@@ -21,9 +21,7 @@
 #  include <deal.II/lac/sparse_matrix.h>
 #  include <deal.II/lac/trilinos_sparsity_pattern.h>
 #  include <deal.II/lac/sparsity_pattern.h>
-#  include <deal.II/lac/compressed_sparsity_pattern.h>
-#  include <deal.II/lac/compressed_set_sparsity_pattern.h>
-#  include <deal.II/lac/compressed_simple_sparsity_pattern.h>
+#  include <deal.II/lac/dynamic_sparsity_pattern.h>
 #  include <deal.II/lac/sparsity_tools.h>
 
 #  include <Epetra_Export.h>
@@ -616,7 +614,7 @@ namespace TrilinosWrappers
   void
   SparseMatrix::reinit (const Epetra_Map    &input_row_map,
                         const Epetra_Map    &input_col_map,
-                        const CompressedSimpleSparsityPattern &sparsity_pattern,
+                        const DynamicSparsityPattern &sparsity_pattern,
                         const bool           exchange_data)
   {
     matrix.reset();
@@ -1710,12 +1708,9 @@ namespace TrilinosWrappers
 {
   template void
   SparseMatrix::reinit (const dealii::SparsityPattern &);
+
   template void
-  SparseMatrix::reinit (const CompressedSparsityPattern &);
-  template void
-  SparseMatrix::reinit (const CompressedSetSparsityPattern &);
-  template void
-  SparseMatrix::reinit (const CompressedSimpleSparsityPattern &);
+  SparseMatrix::reinit (const DynamicSparsityPattern &);
 
   template void
   SparseMatrix::reinit (const Epetra_Map &,
@@ -1723,15 +1718,7 @@ namespace TrilinosWrappers
                         const bool);
   template void
   SparseMatrix::reinit (const Epetra_Map &,
-                        const CompressedSparsityPattern &,
-                        const bool);
-  template void
-  SparseMatrix::reinit (const Epetra_Map &,
-                        const CompressedSetSparsityPattern &,
-                        const bool);
-  template void
-  SparseMatrix::reinit (const Epetra_Map &,
-                        const CompressedSimpleSparsityPattern &,
+                        const DynamicSparsityPattern &,
                         const bool);
 
 
@@ -1740,15 +1727,11 @@ namespace TrilinosWrappers
                         const Epetra_Map &,
                         const dealii::SparsityPattern &,
                         const bool);
+
   template void
   SparseMatrix::reinit (const Epetra_Map &,
                         const Epetra_Map &,
-                        const CompressedSparsityPattern &,
-                        const bool);
-  template void
-  SparseMatrix::reinit (const Epetra_Map &,
-                        const Epetra_Map &,
-                        const CompressedSetSparsityPattern &,
+                        const DynamicSparsityPattern &,
                         const bool);
 
 }
index 3fa461ab4eacbe7c4b4c5740c7cc75d007e0a781..f348004b2eccb954844a384c3ce31b3a050ef0d5 100644 (file)
@@ -19,9 +19,7 @@
 
 #  include <deal.II/base/utilities.h>
 #  include <deal.II/lac/sparsity_pattern.h>
-#  include <deal.II/lac/compressed_sparsity_pattern.h>
-#  include <deal.II/lac/compressed_set_sparsity_pattern.h>
-#  include <deal.II/lac/compressed_simple_sparsity_pattern.h>
+#  include <deal.II/lac/dynamic_sparsity_pattern.h>
 
 #  include <Epetra_Export.h>
 
@@ -1014,11 +1012,7 @@ namespace TrilinosWrappers
   template void
   SparsityPattern::copy_from (const dealii::SparsityPattern &);
   template void
-  SparsityPattern::copy_from (const dealii::CompressedSparsityPattern &);
-  template void
-  SparsityPattern::copy_from (const dealii::CompressedSetSparsityPattern &);
-  template void
-  SparsityPattern::copy_from (const dealii::CompressedSimpleSparsityPattern &);
+  SparsityPattern::copy_from (const dealii::DynamicSparsityPattern &);
 
 
   template void
@@ -1027,17 +1021,8 @@ namespace TrilinosWrappers
                            bool);
   template void
   SparsityPattern::reinit (const Epetra_Map &,
-                           const dealii::CompressedSparsityPattern &,
-                           bool);
-  template void
-  SparsityPattern::reinit (const Epetra_Map &,
-                           const dealii::CompressedSetSparsityPattern &,
+                           const dealii::DynamicSparsityPattern &,
                            bool);
-  template void
-  SparsityPattern::reinit (const Epetra_Map &,
-                           const dealii::CompressedSimpleSparsityPattern &,
-                           bool);
-
 
   template void
   SparsityPattern::reinit (const Epetra_Map &,
@@ -1047,19 +1032,8 @@ namespace TrilinosWrappers
   template void
   SparsityPattern::reinit (const Epetra_Map &,
                            const Epetra_Map &,
-                           const dealii::CompressedSparsityPattern &,
+                           const dealii::DynamicSparsityPattern &,
                            bool);
-  template void
-  SparsityPattern::reinit (const Epetra_Map &,
-                           const Epetra_Map &,
-                           const dealii::CompressedSetSparsityPattern &,
-                           bool);
-  template void
-  SparsityPattern::reinit (const Epetra_Map &,
-                           const Epetra_Map &,
-                           const dealii::CompressedSimpleSparsityPattern &,
-                           bool);
-
 
 
   template void
@@ -1069,17 +1043,7 @@ namespace TrilinosWrappers
                            bool);
   template void
   SparsityPattern::reinit (const IndexSet &,
-                           const dealii::CompressedSparsityPattern &,
-                           const MPI_Comm &,
-                           bool);
-  template void
-  SparsityPattern::reinit (const IndexSet &,
-                           const dealii::CompressedSetSparsityPattern &,
-                           const MPI_Comm &,
-                           bool);
-  template void
-  SparsityPattern::reinit (const IndexSet &,
-                           const dealii::CompressedSimpleSparsityPattern &,
+                           const dealii::DynamicSparsityPattern &,
                            const MPI_Comm &,
                            bool);
 
@@ -1093,19 +1057,7 @@ namespace TrilinosWrappers
   template void
   SparsityPattern::reinit (const IndexSet &,
                            const IndexSet &,
-                           const dealii::CompressedSparsityPattern &,
-                           const MPI_Comm &,
-                           bool);
-  template void
-  SparsityPattern::reinit (const IndexSet &,
-                           const IndexSet &,
-                           const dealii::CompressedSetSparsityPattern &,
-                           const MPI_Comm &,
-                           bool);
-  template void
-  SparsityPattern::reinit (const IndexSet &,
-                           const IndexSet &,
-                           const dealii::CompressedSimpleSparsityPattern &,
+                           const dealii::DynamicSparsityPattern &,
                            const MPI_Comm &,
                            bool);
 
index d9504ae2015743346d48764ccca6e8698fc60984..d992460d0f7a3cc2e6378e7e4c0c74ca7128b700 100644 (file)
@@ -19,6 +19,7 @@
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/index_set.h>
 #include <deal.II/lac/sparsity_pattern.h>
+#include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/compressed_sparsity_pattern.h>
 #include <deal.II/lac/compressed_simple_sparsity_pattern.h>
 #include <deal.II/lac/compressed_set_sparsity_pattern.h>
@@ -53,10 +54,6 @@ void do_reinit (ChunkSparsityPattern &sp)
 }
 
 
-void do_reinit (CompressedSparsityPattern &sp)
-{
-  sp.reinit((N-1)*(N-1), (N-1)*(N-1));
-}
 
 void do_reinit (CompressedSimpleSparsityPattern &sp,
                 const IndexSet &index_set = IndexSet())
@@ -64,10 +61,6 @@ void do_reinit (CompressedSimpleSparsityPattern &sp,
   sp.reinit((N-1)*(N-1), (N-1)*(N-1), index_set);
 }
 
-void do_reinit (CompressedSetSparsityPattern &sp)
-{
-  sp.reinit((N-1)*(N-1), (N-1)*(N-1));
-}
 
 
 
@@ -167,28 +160,13 @@ void copy_with_offdiagonals_1<ChunkSparsityPattern> ()
 
 
 template <>
-void copy_with_offdiagonals_1<CompressedSparsityPattern> ()
+void copy_with_offdiagonals_1<DynamicSparsityPattern> ()
 {
   // this sparsity pattern doesn't have this
   // function
   deallog << "OK" << std::endl;
 }
 
-template <>
-void copy_with_offdiagonals_1<CompressedSimpleSparsityPattern> ()
-{
-  // this sparsity pattern doesn't have this
-  // function
-  deallog << "OK" << std::endl;
-}
-
-template <>
-void copy_with_offdiagonals_1<CompressedSetSparsityPattern> ()
-{
-  // this sparsity pattern doesn't have this
-  // function
-  deallog << "OK" << std::endl;
-}
 
 
 
@@ -225,7 +203,7 @@ void copy_with_offdiagonals_2<ChunkSparsityPattern> ()
 
 
 template <>
-void copy_with_offdiagonals_2<CompressedSparsityPattern> ()
+void copy_with_offdiagonals_2<DynamicSparsityPattern> ()
 {
   // this sparsity pattern doesn't have this
   // function
@@ -234,25 +212,6 @@ void copy_with_offdiagonals_2<CompressedSparsityPattern> ()
 
 
 
-template <>
-void copy_with_offdiagonals_2<CompressedSimpleSparsityPattern> ()
-{
-  // this sparsity pattern doesn't have this
-  // function
-  deallog << "OK" << std::endl;
-}
-
-
-
-template <>
-void copy_with_offdiagonals_2<CompressedSetSparsityPattern> ()
-{
-  // this sparsity pattern doesn't have this
-  // function
-  deallog << "OK" << std::endl;
-}
-
-
 
 void
 do_copy_from (const std::list<std::set<unsigned int,std::greater<unsigned int> > > &sparsity,
@@ -274,49 +233,11 @@ do_copy_from (const std::list<std::set<unsigned int,std::greater<unsigned int> >
 }
 
 
-template <typename SP>
-void
-do_copy_from (const CompressedSparsityPattern &sparsity,
-              SP &sp4)
-{
-  std::list<std::set<unsigned int,std::greater<unsigned int> > > sparsity_x;
-  for (unsigned int i=0; i<sparsity.n_rows(); ++i)
-    {
-      sparsity_x.push_back
-      (std::set<unsigned int,std::greater<unsigned int> >());
-
-      for (unsigned int j=0; j<sparsity.n_cols(); ++j)
-        if (sparsity.exists(i,j))
-          sparsity_x.back().insert (j);
-    }
-
-  do_copy_from (sparsity_x, sp4);
-}
 
 
 template <typename SP>
 void
-do_copy_from (const CompressedSimpleSparsityPattern &sparsity,
-              SP &sp4)
-{
-  std::list<std::set<unsigned int,std::greater<unsigned int> > > sparsity_x;
-  for (unsigned int i=0; i<sparsity.n_rows(); ++i)
-    {
-      sparsity_x.push_back
-      (std::set<unsigned int,std::greater<unsigned int> >());
-
-      for (unsigned int j=0; j<sparsity.n_cols(); ++j)
-        if (sparsity.exists(i,j))
-          sparsity_x.back().insert (j);
-    }
-
-  do_copy_from (sparsity_x, sp4);
-}
-
-
-template <typename SP>
-void
-do_copy_from (const CompressedSetSparsityPattern &sparsity,
+do_copy_from (const DynamicSparsityPattern &sparsity,
               SP &sp4)
 {
   std::list<std::set<unsigned int,std::greater<unsigned int> > > sparsity_x;
@@ -513,16 +434,7 @@ void matrix_position<ChunkSparsityPattern> ()
 
 
 template <>
-void matrix_position<CompressedSparsityPattern> ()
-{
-  // this class doesn't have that function
-  deallog << "OK" << std::endl;
-}
-
-
-
-template <>
-void matrix_position<CompressedSimpleSparsityPattern> ()
+void matrix_position<DynamicSparsityPattern> ()
 {
   // this class doesn't have that function
   deallog << "OK" << std::endl;
@@ -530,13 +442,6 @@ void matrix_position<CompressedSimpleSparsityPattern> ()
 
 
 
-template <>
-void matrix_position<CompressedSetSparsityPattern> ()
-{
-  // this class doesn't have that function
-  deallog << "OK" << std::endl;
-}
-
 
 
 template <typename SP>
@@ -574,7 +479,7 @@ void block_read_write ()
 
 
 template <>
-void block_read_write<CompressedSparsityPattern> ()
+void block_read_write<DynamicSparsityPattern> ()
 {
   // not implemented for this sparsity
   // pattern
@@ -583,25 +488,6 @@ void block_read_write<CompressedSparsityPattern> ()
 
 
 
-template <>
-void block_read_write<CompressedSimpleSparsityPattern> ()
-{
-  // not implemented for this sparsity
-  // pattern
-  deallog << "OK" << std::endl;
-}
-
-
-
-template <>
-void block_read_write<CompressedSetSparsityPattern> ()
-{
-  // not implemented for this sparsity
-  // pattern
-  deallog << "OK" << std::endl;
-}
-
-
 
 template <typename SP>
 void test_index_set (const bool contiguous)

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.