]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
BlockList obsolete
authorkanschat <kanschat@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 26 Sep 2011 15:26:36 +0000 (15:26 +0000)
committerkanschat <kanschat@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 26 Sep 2011 15:26:36 +0000 (15:26 +0000)
git-svn-id: https://svn.dealii.org/trunk@24429 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/doc/news/changes.h
deal.II/include/deal.II/lac/block_list.h
deal.II/include/deal.II/lac/relaxation_block.h
deal.II/include/deal.II/lac/relaxation_block.templates.h

index de6bdb9ecc8a2f54ac7e76d2e3d4f87fe41f5bfd..e030ab9e507110ebc69344c2ea5318352d8d44b1 100644 (file)
@@ -325,6 +325,12 @@ and DoF handlers embedded in higher dimensional space have been added.
 
 <ol>
 
+<li> Improved: The class BlockList used in RelaxationBlock has been replaced
+by SparsityPattern, since it only reproduced its functionality.
+<br>
+(Guido Kanschat, 2011/09/26)
+
+
 <li> New: SparsityPattern::row_position() finds a column index in a row and returns
 its "local" index or numbers::invalid_unsigned_int.
 <br>
index 203e5549aa351081fe700cf30235510b82d22c82..65511f7ac44636d47abbb1cf2d8f3ac26aa16d82 100644 (file)
@@ -15,6 +15,7 @@
 
 #include <deal.II/base/subscriptor.h>
 #include <deal.II/base/template_constraints.h>
+#include <lac/sparsity_pattern.h>
 #include <deal.II/fe/fe.h>
 
 #include <vector>
@@ -22,8 +23,8 @@
 DEAL_II_NAMESPACE_OPEN
 
 /**
- * @warning This class is still experimental and will most likely be
- * changed in a future release.
+ * @deprecated This class is experimental and will be
+ * removed in a future release.
  *
  * A vector of index sets listing the indices of small blocks of a
  * linear system. For each block, the indices in that block are
@@ -52,6 +53,20 @@ class BlockList :
                                     /// The iterator for individual indices
     typedef block_container::const_iterator const_iterator;
 
+                                    /**
+                                     * Since SparsityPattern can
+                                     * handle the tasks of BlockList,
+                                     * this function allows us to
+                                     * create one from an already
+                                     * filled BlockList. A first step
+                                     * to make BlockList obsolete.
+                                     *
+                                     * The additional integer
+                                     * argument is the dimension of
+                                     * the vector space.
+                                     */
+    void create_sparsity_pattern(SparsityPattern& sparsity, unsigned int n) const;
+    
                                     /**
                                      * Add the indices in
                                      * <tt>indices</tt> to block
@@ -271,6 +286,24 @@ class BlockList :
 };
 
 
+inline
+void
+BlockList::create_sparsity_pattern(SparsityPattern& sparsity, unsigned int n) const
+{
+  std::vector<unsigned int> sizes(size());
+  for (unsigned int b=0;b<size();++b)
+    sizes[b] = block_size(b);
+
+  sparsity.reinit(size(), n, sizes);
+  for (unsigned int b=0;b<size();++b)
+    {
+      for (const_iterator i = begin(b); i != end(b); ++i)
+       sparsity.add(b,*i);
+    }
+  sparsity.compress();
+}
+
+
 inline
 void
 BlockList::add(const unsigned int block, const std::vector<unsigned int>& indices)
index d27a5e5fa1a890fe5cd071f6d1bb5b41481ec4ac..07d6c238b7308a9939d742fb40d5f54c6843ab16 100644 (file)
@@ -96,7 +96,7 @@ class RelaxationBlock :
                                          * The mapping from indices
                                          * to blocks.
                                          */
-       BlockList block_list;
+       SparsityPattern block_list;
 
                                         /**
                                          * Relaxation parameter.
index 1e1bf430589ae1c2ed4fbc96d64df077435c6232..65f779280cea6cd20f8c62b0f2c7188323c256bd 100644 (file)
@@ -41,13 +41,14 @@ RelaxationBlock<MATRIX,inverse_type>::AdditionalData::AdditionalData (
   const bool invert_diagonal,
   const bool same_diagonal)
                :
-               block_list(bl),
                relaxation(relaxation),
                invert_diagonal(invert_diagonal),
                same_diagonal(same_diagonal),
                inversion(PreconditionBlockBase<inverse_type>::gauss_jordan),
                threshold(0.)
-{}
+{
+  bl.create_sparsity_pattern(block_list, 0);
+}
 
 
 template <class MATRIX, typename inverse_type>
@@ -65,7 +66,7 @@ RelaxationBlock<MATRIX,inverse_type>::initialize (
   additional_data = &parameters;
   this->inversion = parameters.inversion;
   
-  this->reinit(additional_data->block_list.size(), 0, additional_data->same_diagonal,
+  this->reinit(additional_data->block_list.n_rows(), 0, additional_data->same_diagonal,
               additional_data->inversion);
   
   if (additional_data->invert_diagonal)
@@ -97,15 +98,16 @@ RelaxationBlock<MATRIX,inverse_type>::invert_diagblocks ()
     }
   else
     {
-      for (unsigned int block=0;block<additional_data->block_list.size();++block)
+      for (unsigned int block=0;block<additional_data->block_list.n_rows();++block)
        {
-         const unsigned int bs = additional_data->block_list.block_size(block);
+         const unsigned int bs = additional_data->block_list.row_length(block);
          M_cell.reinit(bs, bs);
 
                                           // Copy rows for this block
                                           // into the matrix for the
                                           // diagonal block
-         BlockList::const_iterator row = additional_data->block_list.begin(block);
+         SparsityPattern::row_iterator row
+           = additional_data->block_list.row_begin(block);
          for (unsigned int row_cell=0; row_cell<bs; ++row_cell, ++row)
            {
 //TODO:[GK] Optimize here
@@ -113,7 +115,7 @@ RelaxationBlock<MATRIX,inverse_type>::invert_diagblocks ()
                   entry != M.end(*row); ++entry)
                {
                  const unsigned int column = entry->column();
-                 const unsigned int col_cell = additional_data->block_list.local_index(block, column);
+                 const unsigned int col_cell = additional_data->block_list.row_position(block, column);
                  if (col_cell != numbers::invalid_unsigned_int)
                    M_cell(row_cell, col_cell) = entry->value();
                }
@@ -168,7 +170,7 @@ RelaxationBlock<MATRIX,inverse_type>::do_step (
   const bool permutation_empty = additional_data->order.size() == 0;
   const unsigned int n_permutations = (permutation_empty)
                                      ? 1U : additional_data->order.size();
-  const unsigned int n_blocks = additional_data->block_list.size();
+  const unsigned int n_blocks = additional_data->block_list.n_rows();
 
   if (!permutation_empty)
     for (unsigned int i=0;i<additional_data->order.size();++i)
@@ -185,12 +187,12 @@ RelaxationBlock<MATRIX,inverse_type>::do_step (
                                        ? (additional_data->order[n_permutations-1-perm][raw_block])
                                        : (additional_data->order[perm][raw_block]));
 
-         const unsigned int bs = additional_data->block_list.block_size(block);
+         const unsigned int bs = additional_data->block_list.row_length(block);
          
          b_cell.reinit(bs);
          x_cell.reinit(bs);
                                           // Collect off-diagonal parts
-         BlockList::const_iterator row = additional_data->block_list.begin(block);
+         SparsityPattern::row_iterator row = additional_data->block_list.row_begin(block);
          for (unsigned int row_cell=0; row_cell<bs; ++row_cell, ++row)
            {
              b_cell(row_cell) = src(*row);
@@ -201,7 +203,7 @@ RelaxationBlock<MATRIX,inverse_type>::do_step (
                                           // Apply inverse diagonal
          this->inverse_vmult(block, x_cell, b_cell);
                                           // Store in result vector
-         row=additional_data->block_list.begin(block);
+         row=additional_data->block_list.row_begin(block);
          for (unsigned int row_cell=0; row_cell<bs; ++row_cell, ++row)
            dst(*row) = prev(*row) + additional_data->relaxation * x_cell(row_cell);
        }

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.