]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Prefer SparsityPatternType to SP and SparsityType. 1941/head
authorDavid Wells <wellsd2@rpi.edu>
Sun, 6 Dec 2015 23:40:46 +0000 (18:40 -0500)
committerDavid Wells <wellsd2@rpi.edu>
Sun, 6 Dec 2015 23:40:46 +0000 (18:40 -0500)
This commit uses SparsityPatternType as the template concept name for
things resembling a sparsity pattern. This replaces a few other template
parameters.

23 files changed:
include/deal.II/dofs/dof_tools.h
include/deal.II/lac/block_sparsity_pattern.h
include/deal.II/lac/chunk_sparsity_pattern.h
include/deal.II/lac/constraint_matrix.h
include/deal.II/lac/constraint_matrix.templates.h
include/deal.II/lac/petsc_parallel_sparse_matrix.h
include/deal.II/lac/petsc_sparse_matrix.h
include/deal.II/lac/sparsity_pattern.h
include/deal.II/lac/trilinos_block_sparse_matrix.h
include/deal.II/lac/trilinos_sparse_matrix.h
include/deal.II/lac/trilinos_sparsity_pattern.h
include/deal.II/multigrid/mg_tools.h
include/deal.II/multigrid/mg_transfer.h
source/dofs/dof_tools_sparsity.cc
source/lac/chunk_sparsity_pattern.cc
source/lac/constraint_matrix.cc
source/lac/petsc_parallel_sparse_matrix.cc
source/lac/petsc_sparse_matrix.cc
source/lac/sparsity_pattern.cc
source/lac/trilinos_block_sparse_matrix.cc
source/lac/trilinos_sparse_matrix.cc
source/lac/trilinos_sparsity_pattern.cc
source/multigrid/mg_tools.cc

index 9c61c9535ee4584bf6b5b10f02a51058ac349ca1..975d1eac13460db7075bb0ad96db7809af7c4985 100644 (file)
@@ -395,13 +395,13 @@ namespace DoFTools
    *
    * @ingroup constraints
    */
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
-  make_sparsity_pattern (const DoFHandlerType   &dof,
-                         SP                     &sparsity_pattern,
-                         const ConstraintMatrix &constraints = ConstraintMatrix(),
-                         const bool              keep_constrained_dofs = true,
-                         const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id);
+  make_sparsity_pattern (const DoFHandlerType      &dof,
+                         SparsityPatternType       &sparsity_pattern,
+                         const ConstraintMatrix    &constraints           = ConstraintMatrix(),
+                         const bool                 keep_constrained_dofs = true,
+                         const types::subdomain_id  subdomain_id          = numbers::invalid_subdomain_id);
 
   /**
    * Locate non-zero entries for vector valued finite elements.  This function
@@ -484,14 +484,14 @@ namespace DoFTools
    *
    * @ingroup constraints
    */
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
   make_sparsity_pattern (const DoFHandlerType     &dof,
                          const Table<2, Coupling> &coupling,
-                         SP                       &sparsity_pattern,
-                         const ConstraintMatrix   &constraints = ConstraintMatrix(),
+                         SparsityPatternType      &sparsity_pattern,
+                         const ConstraintMatrix   &constraints           = ConstraintMatrix(),
                          const bool                keep_constrained_dofs = true,
-                         const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id);
+                         const types::subdomain_id subdomain_id         = numbers::invalid_subdomain_id);
 
   /**
    * Construct a sparsity pattern that allows coupling degrees of freedom on
@@ -513,11 +513,11 @@ namespace DoFTools
    * whereas the ones that correspond to columns come from the second
    * DoFHandler.
    */
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
-  make_sparsity_pattern (const DoFHandlerType        &dof_row,
-                         const DoFHandlerType        &dof_col,
-                         SP              &sparsity);
+  make_sparsity_pattern (const DoFHandlerType &dof_row,
+                         const DoFHandlerType &dof_col,
+                         SparsityPatternType  &sparsity);
 
   /**
    * Create the sparsity pattern for boundary matrices. See the general
@@ -529,11 +529,11 @@ namespace DoFTools
    * class that satisfies similar requirements. It is assumed that the size of
    * the sparsity pattern is already correct.
    */
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
-  make_boundary_sparsity_pattern (const DoFHandlerType            &dof,
+  make_boundary_sparsity_pattern (const DoFHandlerType                       &dof,
                                   const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
-                                  SP                              &sparsity_pattern);
+                                  SparsityPatternType                        &sparsity_pattern);
 
   /**
    * Write the sparsity structure of the matrix composed of the basis
@@ -551,12 +551,13 @@ namespace DoFTools
    *
    * For the type of the sparsity pattern, the same holds as said above.
    */
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
-  make_boundary_sparsity_pattern (const DoFHandlerType &dof,
-                                  const typename FunctionMap<DoFHandlerType::space_dimension>::type &boundary_ids,
-                                  const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
-                                  SP                 &sparsity);
+  make_boundary_sparsity_pattern
+  (const DoFHandlerType                                              &dof,
+   const typename FunctionMap<DoFHandlerType::space_dimension>::type &boundary_ids,
+   const std::vector<types::global_dof_index>                        &dof_to_boundary_mapping,
+   SparsityPatternType                                               &sparsity);
 
   /**
    * Generate sparsity pattern for fluxes, i.e. formulations of the discrete
@@ -566,10 +567,10 @@ namespace DoFTools
    * neighboring elements, the normal couplings and these extra matrix entries
    * are considered.
    */
-  template<typename DoFHandlerType, class SP>
+  template<typename DoFHandlerType, typename SparsityPatternType>
   void
   make_flux_sparsity_pattern (const DoFHandlerType &dof_handler,
-                              SP       &sparsity_pattern);
+                              SparsityPatternType  &sparsity_pattern);
 
   /**
    * This function does the same as the other with the same name, but it gets
@@ -578,13 +579,13 @@ namespace DoFTools
    *
    * @ingroup constraints
    */
-  template<typename DoFHandlerType, class SP>
+  template<typename DoFHandlerType, typename SparsityPatternType>
   void
-  make_flux_sparsity_pattern (const DoFHandlerType        &dof_handler,
-                              SP              &sparsity_pattern,
-                              const ConstraintMatrix   &constraints,
-                              const bool                keep_constrained_dofs = true,
-                              const types::subdomain_id  subdomain_id = numbers::invalid_unsigned_int);
+  make_flux_sparsity_pattern (const DoFHandlerType      &dof_handler,
+                              SparsityPatternType       &sparsity_pattern,
+                              const ConstraintMatrix    &constraints,
+                              const bool                 keep_constrained_dofs = true,
+                              const types::subdomain_id  subdomain_id          = numbers::invalid_unsigned_int);
 
   /**
    * This function does the same as the other with the same name, but it gets
@@ -597,10 +598,10 @@ namespace DoFTools
    *
    * @todo Not implemented for hp::DoFHandler.
    */
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
   make_flux_sparsity_pattern (const DoFHandlerType    &dof,
-                              SP                      &sparsity,
+                              SparsityPatternType     &sparsity,
                               const Table<2,Coupling> &int_mask,
                               const Table<2,Coupling> &flux_mask);
 
index 6c88fb7683c6c10348ede9d3a8a95150a75a5091..14c04a5b0122b137556e7713982eefb3dcece825 100644 (file)
@@ -79,7 +79,7 @@ namespace TrilinosWrappers
  * @ref GlossBlockLA "Block (linear algebra)"
  * @author Wolfgang Bangerth, 2000, 2001
  */
-template <class SP>
+template <typename SparsityPatternType>
 class BlockSparsityPatternBase : public Subscriptor
 {
 public:
@@ -160,7 +160,7 @@ public:
   /**
    * Access the block with the given coordinates.
    */
-  SP &
+  SparsityPatternType &
   block (const size_type row,
          const size_type column);
 
@@ -169,7 +169,7 @@ public:
    * Access the block with the given coordinates. Version for constant
    * objects.
    */
-  const SP &
+  const SparsityPatternType &
   block (const size_type row,
          const size_type column) const;
 
@@ -338,7 +338,7 @@ protected:
   /**
    * Array of sparsity patterns.
    */
-  Table<2,SmartPointer<SP, BlockSparsityPatternBase<SP> > > sub_objects;
+  Table<2,SmartPointer<SparsityPatternType, BlockSparsityPatternBase<SparsityPatternType> > > sub_objects;
 
   /**
    * Object storing and managing the transformation of row indices to indices
@@ -749,11 +749,11 @@ namespace TrilinosWrappers
 
 
 
-template <class SP>
+template <typename SparsityPatternType>
 inline
-SP &
-BlockSparsityPatternBase<SP>::block (const size_type row,
-                                     const size_type column)
+SparsityPatternType &
+BlockSparsityPatternBase<SparsityPatternType>::block (const size_type row,
+                                                      const size_type column)
 {
   Assert (row<rows, ExcIndexRange(row,0,rows));
   Assert (column<columns, ExcIndexRange(column,0,columns));
@@ -762,11 +762,11 @@ BlockSparsityPatternBase<SP>::block (const size_type row,
 
 
 
-template <class SP>
+template <typename SparsityPatternType>
 inline
-const SP &
-BlockSparsityPatternBase<SP>::block (const size_type row,
-                                     const size_type column) const
+const SparsityPatternType &
+BlockSparsityPatternBase<SparsityPatternType>::block (const size_type row,
+                                                      const size_type column) const
 {
   Assert (row<rows, ExcIndexRange(row,0,rows));
   Assert (column<columns, ExcIndexRange(column,0,columns));
@@ -775,31 +775,31 @@ BlockSparsityPatternBase<SP>::block (const size_type row,
 
 
 
-template <class SP>
+template <typename SparsityPatternType>
 inline
 const BlockIndices &
-BlockSparsityPatternBase<SP>::get_row_indices () const
+BlockSparsityPatternBase<SparsityPatternType>::get_row_indices () const
 {
   return row_indices;
 }
 
 
 
-template <class SP>
+template <typename SparsityPatternType>
 inline
 const BlockIndices &
-BlockSparsityPatternBase<SP>::get_column_indices () const
+BlockSparsityPatternBase<SparsityPatternType>::get_column_indices () const
 {
   return column_indices;
 }
 
 
 
-template <class SP>
+template <typename SparsityPatternType>
 inline
 void
-BlockSparsityPatternBase<SP>::add (const size_type i,
-                                   const size_type j)
+BlockSparsityPatternBase<SparsityPatternType>::add (const size_type i,
+                                                    const size_type j)
 {
   // if you get an error here, are
   // you sure you called
@@ -813,13 +813,13 @@ BlockSparsityPatternBase<SP>::add (const size_type i,
 
 
 
-template <class SP>
+template <typename SparsityPatternType>
 template <typename ForwardIterator>
 void
-BlockSparsityPatternBase<SP>::add_entries (const size_type row,
-                                           ForwardIterator begin,
-                                           ForwardIterator end,
-                                           const bool      indices_are_sorted)
+BlockSparsityPatternBase<SparsityPatternType>::add_entries (const size_type row,
+                                                            ForwardIterator begin,
+                                                            ForwardIterator end,
+                                                            const bool      indices_are_sorted)
 {
   // Resize scratch arrays
   if (block_column_indices.size() < this->n_block_cols())
@@ -900,11 +900,11 @@ BlockSparsityPatternBase<SP>::add_entries (const size_type row,
 
 
 
-template <class SP>
+template <typename SparsityPatternType>
 inline
 bool
-BlockSparsityPatternBase<SP>::exists (const size_type i,
-                                      const size_type j) const
+BlockSparsityPatternBase<SparsityPatternType>::exists (const size_type i,
+                                                       const size_type j) const
 {
   // if you get an error here, are
   // you sure you called
@@ -918,10 +918,10 @@ BlockSparsityPatternBase<SP>::exists (const size_type i,
 
 
 
-template <class SP>
+template <typename SparsityPatternType>
 inline
 unsigned int
-BlockSparsityPatternBase<SP>::
+BlockSparsityPatternBase<SparsityPatternType>::
 row_length (const size_type row) const
 {
   const std::pair<size_type , size_type>
@@ -937,20 +937,20 @@ row_length (const size_type row) const
 
 
 
-template <class SP>
+template <typename SparsityPatternType>
 inline
-typename BlockSparsityPatternBase<SP>::size_type
-BlockSparsityPatternBase<SP>::n_block_cols () const
+typename BlockSparsityPatternBase<SparsityPatternType>::size_type
+BlockSparsityPatternBase<SparsityPatternType>::n_block_cols () const
 {
   return columns;
 }
 
 
 
-template <class SP>
+template <typename SparsityPatternType>
 inline
-typename BlockSparsityPatternBase<SP>::size_type
-BlockSparsityPatternBase<SP>::n_block_rows () const
+typename BlockSparsityPatternBase<SparsityPatternType>::size_type
+BlockSparsityPatternBase<SparsityPatternType>::n_block_rows () const
 {
   return rows;
 }
index 4ecaa669d086be81cddd6427ba83efe0a24edf84..97b95d60e4377c9e86543aa5eacbc001dc61dbc7 100644 (file)
@@ -485,9 +485,9 @@ public:
    * of this object is lost, and the sparsity pattern is in compressed mode
    * afterwards.
    */
-  template <typename SparsityType>
-  void copy_from (const SparsityType &dsp,
-                  const size_type     chunk_size);
+  template <typename SparsityPatternType>
+  void copy_from (const SparsityPatternType &dsp,
+                  const size_type            chunk_size);
 
   /**
    * Take a full matrix and use its nonzero entries to generate a sparse
index 13f16df2a36b5ab6ce6889491762c6aaea0ed538..d8f0ab33a1cf46b63a25ce630bbd95d260c4aec2 100644 (file)
@@ -940,23 +940,23 @@ public:
    * caller's site. There is no locking mechanism inside this method to
    * prevent data races.
    */
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   void
   add_entries_local_to_global (const std::vector<size_type> &local_dof_indices,
-                               SparsityType                 &sparsity_pattern,
+                               SparsityPatternType          &sparsity_pattern,
                                const bool                    keep_constrained_entries = true,
-                               const Table<2,bool>          &dof_mask = default_empty_table) const;
+                               const Table<2,bool>          &dof_mask                 = default_empty_table) const;
 
   /**
    * Similar to the other function, but for non-quadratic sparsity patterns.
    */
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   void
   add_entries_local_to_global (const std::vector<size_type> &row_indices,
                                const std::vector<size_type> &col_indices,
-                               SparsityType                 &sparsity_pattern,
+                               SparsityPatternType          &sparsity_pattern,
                                const bool                    keep_constrained_entries = true,
-                               const Table<2,bool>          &dof_mask = default_empty_table) const;
+                               const Table<2,bool>          &dof_mask                 = default_empty_table) const;
 
   /**
    * This function imports values from a global vector (@p global_vector) by
@@ -1283,10 +1283,10 @@ private:
    * This function actually implements the local_to_global function for
    * standard (non-block) sparsity types.
    */
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   void
   add_entries_local_to_global (const std::vector<size_type> &local_dof_indices,
-                               SparsityType                 &sparsity_pattern,
+                               SparsityPatternType          &sparsity_pattern,
                                const bool                    keep_constrained_entries,
                                const Table<2,bool>          &dof_mask,
                                internal::bool2type<false>) const;
@@ -1295,10 +1295,10 @@ private:
    * This function actually implements the local_to_global function for block
    * sparsity types.
    */
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   void
   add_entries_local_to_global (const std::vector<size_type> &local_dof_indices,
-                               SparsityType                 &sparsity_pattern,
+                               SparsityPatternType          &sparsity_pattern,
                                const bool                    keep_constrained_entries,
                                const Table<2,bool>          &dof_mask,
                                internal::bool2type<true>) const;
@@ -1311,8 +1311,8 @@ private:
    * the global row indices.
    */
   void
-  make_sorted_row_list (const std::vector<size_type> &local_dof_indices,
-                        internals::GlobalRowsFromLocal  &global_rows) const;
+  make_sorted_row_list (const std::vector<size_type>   &local_dof_indices,
+                        internals::GlobalRowsFromLocal &global_rows) const;
 
   /**
    * Internal helper function for add_entries_local_to_global function.
@@ -1656,7 +1656,7 @@ void ConstraintMatrix::get_dof_values (const VectorType  &global_vector,
 
 
 template <typename MatrixType> class BlockMatrixBase;
-template <typename SparsityType> class BlockSparsityPatternBase;
+template <typename SparsityPatternType> class BlockSparsityPatternBase;
 template <typename number>     class BlockSparseMatrixEZ;
 
 /**
@@ -1776,12 +1776,12 @@ distribute_local_to_global (const FullMatrix<typename MatrixType::value_type>
 
 
 
-template <typename SparsityType>
+template <typename SparsityPatternType>
 inline
 void
 ConstraintMatrix::
 add_entries_local_to_global (const std::vector<size_type> &local_dof_indices,
-                             SparsityType                 &sparsity_pattern,
+                             SparsityPatternType          &sparsity_pattern,
                              const bool                    keep_constrained_entries,
                              const Table<2,bool>          &dof_mask) const
 {
@@ -1789,7 +1789,7 @@ add_entries_local_to_global (const std::vector<size_type> &local_dof_indices,
   // the actual implementation follows in the cm.templates.h file.
   add_entries_local_to_global (local_dof_indices, sparsity_pattern,
                                keep_constrained_entries, dof_mask,
-                               internal::bool2type<IsBlockMatrix<SparsityType>::value>());
+                               internal::bool2type<IsBlockMatrix<SparsityPatternType>::value>());
 }
 
 
index e7bb325d19ef683a55a0c179955b99d97d37de7d..a62c1298038858f7eaf19491b4d678f147125263 100644 (file)
@@ -1957,13 +1957,13 @@ add_this_index:
   // add_entries_local_to_global. In case we keep constrained entries, add all
   // the rows and columns related to the constrained dof, otherwise just add
   // the diagonal
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   inline void
   set_sparsity_diagonals (const internals::GlobalRowsFromLocal &global_rows,
                           const std::vector<size_type>         &local_dof_indices,
                           const Table<2,bool>                  &dof_mask,
                           const bool                            keep_constrained_entries,
-                          SparsityType                         &sparsity_pattern)
+                          SparsityPatternType                  &sparsity_pattern)
   {
     // if we got constraints, need to add the diagonal element and, if the
     // user requested so, also the rest of the entries in rows and columns
@@ -2450,11 +2450,11 @@ distribute_local_to_global (const FullMatrix<typename MatrixType::value_type>  &
 
 
 
-template <typename SparsityType>
+template <typename SparsityPatternType>
 void
 ConstraintMatrix::
 add_entries_local_to_global (const std::vector<size_type> &local_dof_indices,
-                             SparsityType                 &sparsity_pattern,
+                             SparsityPatternType          &sparsity_pattern,
                              const bool                    keep_constrained_entries,
                              const Table<2,bool>          &dof_mask,
                              internal::bool2type<false> ) const
@@ -2544,12 +2544,12 @@ add_entries_local_to_global (const std::vector<size_type> &local_dof_indices,
 
 
 
-template <typename SparsityType>
+template <typename SparsityPatternType>
 void
 ConstraintMatrix::
 add_entries_local_to_global (const std::vector<size_type> &row_indices,
                              const std::vector<size_type> &col_indices,
-                             SparsityType                 &sparsity_pattern,
+                             SparsityPatternType          &sparsity_pattern,
                              const bool                    keep_constrained_entries,
                              const Table<2,bool>          &dof_mask) const
 {
@@ -2603,11 +2603,11 @@ add_entries_local_to_global (const std::vector<size_type> &row_indices,
 
 
 
-template <typename SparsityType>
+template <typename SparsityPatternType>
 void
 ConstraintMatrix::
 add_entries_local_to_global (const std::vector<size_type> &local_dof_indices,
-                             SparsityType                 &sparsity_pattern,
+                             SparsityPatternType          &sparsity_pattern,
                              const bool                    keep_constrained_entries,
                              const Table<2,bool>          &dof_mask,
                              internal::bool2type<true> ) const
index b10c92f6e9165aa4d8e6ca354cc9646a328082ce..b97810e8c87eb0f6270683b677f850c5908ed171 100644 (file)
@@ -232,9 +232,9 @@ namespace PETScWrappers
        * greatly slow down your program. It is therefore significantly more
        * efficient to get memory allocation right from the start.
        */
-      template <typename SparsityType>
+      template <typename SparsityPatternType>
       SparseMatrix (const MPI_Comm               &communicator,
-                    const SparsityType           &sparsity_pattern,
+                    const SparsityPatternType    &sparsity_pattern,
                     const std::vector<size_type> &local_rows_per_process,
                     const std::vector<size_type> &local_columns_per_process,
                     const unsigned int            this_process,
@@ -305,9 +305,9 @@ namespace PETScWrappers
        * greatly slow down your program. It is therefore significantly more
        * efficient to get memory allocation right from the start.
        */
-      template <typename SparsityType>
+      template <typename SparsityPatternType>
       void reinit (const MPI_Comm               &communicator,
-                   const SparsityType           &sparsity_pattern,
+                   const SparsityPatternType    &sparsity_pattern,
                    const std::vector<size_type> &local_rows_per_process,
                    const std::vector<size_type> &local_columns_per_process,
                    const unsigned int            this_process,
@@ -319,11 +319,11 @@ namespace PETScWrappers
        * give the rows and columns for the calling processor. Note that only
        * contiguous IndexSets are supported.
        */
-      template <typename SparsityType>
-      void reinit (const IndexSet &local_rows,
-                   const IndexSet &local_columns,
-                   const SparsityType         &sparsity_pattern,
-                   const MPI_Comm                  &communicator);
+      template <typename SparsityPatternType>
+      void reinit (const IndexSet            &local_rows,
+                   const IndexSet            &local_columns,
+                   const SparsityPatternType &sparsity_pattern,
+                   const MPI_Comm            &communicator);
 
       /**
        * Initialize this matrix to have the same structure as @p other. This
@@ -413,8 +413,8 @@ namespace PETScWrappers
       /**
        * Same as previous functions.
        */
-      template <typename SparsityType>
-      void do_reinit (const SparsityType           &sparsity_pattern,
+      template <typename SparsityPatternType>
+      void do_reinit (const SparsityPatternType    &sparsity_pattern,
                       const std::vector<size_type> &local_rows_per_process,
                       const std::vector<size_type> &local_columns_per_process,
                       const unsigned int            this_process,
@@ -423,10 +423,10 @@ namespace PETScWrappers
       /**
        * Same as previous functions.
        */
-      template <typename SparsityType>
-      void do_reinit (const IndexSet &local_rows,
-                      const IndexSet &local_columns,
-                      const SparsityType         &sparsity_pattern);
+      template <typename SparsityPatternType>
+      void do_reinit (const IndexSet            &local_rows,
+                      const IndexSet            &local_columns,
+                      const SparsityPatternType &sparsity_pattern);
 
       /**
        * To allow calling protected prepare_add() and prepare_set().
index 515abd62bd8ca379c0f018595e4c1d517bb5361a..131fa4b796f19d0f06f0952a6a232bacf690fa0f 100644 (file)
@@ -127,9 +127,9 @@ namespace PETScWrappers
      * greatly slow down your program. It is therefore significantly more
      * efficient to get memory allocation right from the start.
      */
-    template <typename SparsityType>
-    explicit SparseMatrix (const SparsityType &sparsity_pattern,
-                           const bool          preset_nonzero_locations = true);
+    template <typename SparsityPatternType>
+    explicit SparseMatrix (const SparsityPatternType &sparsity_pattern,
+                           const bool                 preset_nonzero_locations = true);
 
     /**
      * This operator assigns a scalar to a matrix. Since this does usually not
@@ -187,9 +187,9 @@ namespace PETScWrappers
      * once; nevertheless, given the fact that it is inefficient, the
      * respective flag has a default value equal to @p false.
      */
-    template <typename SparsityType>
-    void reinit (const SparsityType &sparsity_pattern,
-                 const bool          preset_nonzero_locations = true);
+    template <typename SparsityPatternType>
+    void reinit (const SparsityPatternType &sparsity_pattern,
+                 const bool                 preset_nonzero_locations = true);
 
     /**
      * Return a reference to the MPI communicator object in use with this
@@ -257,9 +257,9 @@ namespace PETScWrappers
     /**
      * Same as previous function.
      */
-    template <typename SparsityType>
-    void do_reinit (const SparsityType &sparsity_pattern,
-                    const bool          preset_nonzero_locations);
+    template <typename SparsityPatternType>
+    void do_reinit (const SparsityPatternType &sparsity_pattern,
+                    const bool                 preset_nonzero_locations);
 
     /**
      * To allow calling protected prepare_add() and prepare_set().
index ea9a3190e3743d09d3f9dabc14de6025c0d766b8..dc34ffa8651e7d66732b6d8964418174ca53d133 100644 (file)
@@ -624,8 +624,8 @@ public:
    * content of this object is lost, and the sparsity pattern is in compressed
    * mode afterwards.
    */
-  template <typename CompressedSparsityType>
-  void copy_from (const CompressedSparsityType &dsp);
+  template <typename SparsityPatternType>
+  void copy_from (const SparsityPatternType &dsp);
 
 
   /**
index 6001c8064b60c3156ca04ff2c7b057fa4fb404de..7e7ce17176a7698ab7db79cc99c46dd04ecb28b1 100644 (file)
@@ -153,29 +153,29 @@ namespace TrilinosWrappers
      * %parallel distribution of the individual matrices. This function
      * assumes that a quadratic block matrix is generated.
      */
-    template <typename BlockSparsityType>
-    void reinit (const std::vector<Epetra_Map> &input_maps,
-                 const BlockSparsityType       &block_sparsity_pattern,
-                 const bool                   exchange_data = false);
+    template <typename BlockSparsityPatternType>
+    void reinit (const std::vector<Epetra_Map>  &input_maps,
+                 const BlockSparsityPatternType &block_sparsity_pattern,
+                 const bool                      exchange_data = false);
 
     /**
      * Resize the matrix, by using an array of index sets to determine the
      * %parallel distribution of the individual matrices. This function
      * assumes that a quadratic block matrix is generated.
      */
-    template <typename BlockSparsityType>
-    void reinit (const std::vector<IndexSet> &input_maps,
-                 const BlockSparsityType     &block_sparsity_pattern,
-                 const MPI_Comm              &communicator = MPI_COMM_WORLD,
-                 const bool                   exchange_data = false);
+    template <typename BlockSparsityPatternType>
+    void reinit (const std::vector<IndexSet>    &input_maps,
+                 const BlockSparsityPatternType &block_sparsity_pattern,
+                 const MPI_Comm                 &communicator  = MPI_COMM_WORLD,
+                 const bool                      exchange_data = false);
 
     /**
      * Resize the matrix and initialize it by the given sparsity pattern.
      * Since no distribution map is given, the result is a block matrix for
      * which all elements are stored locally.
      */
-    template <typename BlockSparsityType>
-    void reinit (const BlockSparsityType &block_sparsity_pattern);
+    template <typename BlockSparsityPatternType>
+    void reinit (const BlockSparsityPatternType &block_sparsity_pattern);
 
     /**
      * This function initializes the Trilinos matrix using the deal.II sparse
index e47e8f513ead5bb684f89a00663d241eb897ea75..ec9d25d3182b5d6957798faa123e76be383e9897 100644 (file)
@@ -584,8 +584,8 @@ namespace TrilinosWrappers
      * This is a collective operation that needs to be called on all
      * processors in order to avoid a dead lock.
      */
-    template<typename SparsityType>
-    void reinit (const SparsityType &sparsity_pattern);
+    template<typename SparsityPatternType>
+    void reinit (const SparsityPatternType &sparsity_pattern);
 
     /**
      * This function reinitializes the Trilinos sparse matrix from a (possibly
@@ -746,10 +746,10 @@ namespace TrilinosWrappers
      *
      * @deprecated Use the respective method with IndexSet argument instead.
      */
-    template<typename SparsityType>
-    void reinit (const Epetra_Map    &parallel_partitioning,
-                 const SparsityType  &sparsity_pattern,
-                 const bool          exchange_data = false) DEAL_II_DEPRECATED;
+    template<typename SparsityPatternType>
+    void reinit (const Epetra_Map          &parallel_partitioning,
+                 const SparsityPatternType &sparsity_pattern,
+                 const bool                 exchange_data = false) DEAL_II_DEPRECATED;
 
     /**
      * This function is similar to the other initialization function above,
@@ -765,11 +765,11 @@ namespace TrilinosWrappers
      *
      * @deprecated Use the respective method with IndexSet argument instead.
      */
-    template<typename SparsityType>
-    void reinit (const Epetra_Map    &row_parallel_partitioning,
-                 const Epetra_Map    &col_parallel_partitioning,
-                 const SparsityType  &sparsity_pattern,
-                 const bool          exchange_data = false) DEAL_II_DEPRECATED;
+    template<typename SparsityPatternType>
+    void reinit (const Epetra_Map          &row_parallel_partitioning,
+                 const Epetra_Map          &col_parallel_partitioning,
+                 const SparsityPatternType &sparsity_pattern,
+                 const bool                 exchange_data = false) DEAL_II_DEPRECATED;
 
     /**
      * This function initializes the Trilinos matrix using the deal.II sparse
@@ -908,11 +908,11 @@ namespace TrilinosWrappers
      * This is a collective operation that needs to be called on all
      * processors in order to avoid a dead lock.
      */
-    template<typename SparsityType>
-    void reinit (const IndexSet      &parallel_partitioning,
-                 const SparsityType  &sparsity_pattern,
-                 const MPI_Comm      &communicator = MPI_COMM_WORLD,
-                 const bool           exchange_data = false);
+    template<typename SparsityPatternType>
+    void reinit (const IndexSet            &parallel_partitioning,
+                 const SparsityPatternType &sparsity_pattern,
+                 const MPI_Comm            &communicator  = MPI_COMM_WORLD,
+                 const bool                 exchange_data = false);
 
     /**
      * This function is similar to the other initialization function above,
@@ -926,12 +926,12 @@ namespace TrilinosWrappers
      * This is a collective operation that needs to be called on all
      * processors in order to avoid a dead lock.
      */
-    template<typename SparsityType>
-    void reinit (const IndexSet      &row_parallel_partitioning,
-                 const IndexSet      &col_parallel_partitioning,
-                 const SparsityType  &sparsity_pattern,
-                 const MPI_Comm      &communicator = MPI_COMM_WORLD,
-                 const bool           exchange_data = false);
+    template<typename SparsityPatternType>
+    void reinit (const IndexSet            &row_parallel_partitioning,
+                 const IndexSet            &col_parallel_partitioning,
+                 const SparsityPatternType &sparsity_pattern,
+                 const MPI_Comm            &communicator  = MPI_COMM_WORLD,
+                 const bool                 exchange_data = false);
 
     /**
      * This function initializes the Trilinos matrix using the deal.II sparse
@@ -2604,12 +2604,12 @@ namespace TrilinosWrappers
 
 
 
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   inline
-  void SparseMatrix::reinit (const IndexSet      &parallel_partitioning,
-                             const SparsityType  &sparsity_pattern,
-                             const MPI_Comm      &communicator,
-                             const bool           exchange_data)
+  void SparseMatrix::reinit (const IndexSet            &parallel_partitioning,
+                             const SparsityPatternType &sparsity_pattern,
+                             const MPI_Comm            &communicator,
+                             const bool                 exchange_data)
   {
     reinit (parallel_partitioning, parallel_partitioning,
             sparsity_pattern, communicator, exchange_data);
@@ -2619,12 +2619,12 @@ namespace TrilinosWrappers
 
   template <typename number>
   inline
-  void SparseMatrix::reinit (const IndexSet      &parallel_partitioning,
+  void SparseMatrix::reinit (const IndexSet                       &parallel_partitioning,
                              const ::dealii::SparseMatrix<number> &sparse_matrix,
-                             const MPI_Comm      &communicator,
-                             const double         drop_tolerance,
-                             const bool           copy_values,
-                             const ::dealii::SparsityPattern *use_this_sparsity)
+                             const MPI_Comm                       &communicator,
+                             const double                          drop_tolerance,
+                             const bool                            copy_values,
+                             const ::dealii::SparsityPattern      *use_this_sparsity)
   {
     Epetra_Map map = parallel_partitioning.make_trilinos_map (communicator, false);
     reinit (parallel_partitioning, parallel_partitioning, sparse_matrix,
index cde022917edccd7756011bd04e75e836ffd24b65..ff3a993c56d436927c36176a77afe67d04716c33 100644 (file)
@@ -373,9 +373,9 @@ namespace TrilinosWrappers
      * parallel, this function uses an ad-hoc partitioning of the rows and
      * columns.
      */
-    template<typename SparsityType>
+    template<typename SparsityPatternType>
     void
-    copy_from (const SparsityType &nontrilinos_sparsity_pattern);
+    copy_from (const SparsityPatternType &nontrilinos_sparsity_pattern);
 
     /**
      * Copy operator. This operation is only allowed for empty objects, to
@@ -568,12 +568,12 @@ namespace TrilinosWrappers
      *
      * @deprecated Use the respective method with IndexSet argument instead.
      */
-    template<typename SparsityType>
+    template<typename SparsityPatternType>
     void
-    reinit (const Epetra_Map   &row_parallel_partitioning,
-            const Epetra_Map   &col_parallel_partitioning,
-            const SparsityType &nontrilinos_sparsity_pattern,
-            const bool          exchange_data = false) DEAL_II_DEPRECATED;
+    reinit (const Epetra_Map          &row_parallel_partitioning,
+            const Epetra_Map          &col_parallel_partitioning,
+            const SparsityPatternType &nontrilinos_sparsity_pattern,
+            const bool                 exchange_data = false) DEAL_II_DEPRECATED;
 
     /**
      * Reinit function. Takes one of the deal.II sparsity patterns and a
@@ -585,11 +585,11 @@ namespace TrilinosWrappers
      *
      * @deprecated Use the respective method with IndexSet argument instead.
      */
-    template<typename SparsityType>
+    template<typename SparsityPatternType>
     void
-    reinit (const Epetra_Map   &parallel_partitioning,
-            const SparsityType &nontrilinos_sparsity_pattern,
-            const bool          exchange_data = false) DEAL_II_DEPRECATED;
+    reinit (const Epetra_Map          &parallel_partitioning,
+            const SparsityPatternType &nontrilinos_sparsity_pattern,
+            const bool                 exchange_data = false) DEAL_II_DEPRECATED;
 //@}
     /**
      * @name Constructors and initialization using an IndexSet description
@@ -800,13 +800,13 @@ namespace TrilinosWrappers
      * constructed. This feature is only implemented for input sparsity
      * patterns of type DynamicSparsityPattern.
      */
-    template<typename SparsityType>
+    template<typename SparsityPatternType>
     void
-    reinit (const IndexSet     &row_parallel_partitioning,
-            const IndexSet     &col_parallel_partitioning,
-            const SparsityType &nontrilinos_sparsity_pattern,
-            const MPI_Comm     &communicator = MPI_COMM_WORLD,
-            const bool          exchange_data = false);
+    reinit (const IndexSet            &row_parallel_partitioning,
+            const IndexSet            &col_parallel_partitioning,
+            const SparsityPatternType &nontrilinos_sparsity_pattern,
+            const MPI_Comm            &communicator  = MPI_COMM_WORLD,
+            const bool                 exchange_data = false);
 
     /**
      * Reinit function. Takes one of the deal.II sparsity patterns and a
@@ -816,12 +816,12 @@ namespace TrilinosWrappers
      * that is not fully constructed. This feature is only implemented for
      * input sparsity patterns of type DynamicSparsityPattern.
      */
-    template<typename SparsityType>
+    template<typename SparsityPatternType>
     void
-    reinit (const IndexSet     &parallel_partitioning,
-            const SparsityType &nontrilinos_sparsity_pattern,
-            const MPI_Comm     &communicator = MPI_COMM_WORLD,
-            const bool          exchange_data = false);
+    reinit (const IndexSet            &parallel_partitioning,
+            const SparsityPatternType &nontrilinos_sparsity_pattern,
+            const MPI_Comm            &communicator  = MPI_COMM_WORLD,
+            const bool                 exchange_data = false);
 //@}
     /**
      * @name Information on the sparsity pattern
index 233bee6de07b3588af38b2ab364daf046bf3fc0a..63d1de53680fe40812618c805fbc7b4725a05b1b 100644 (file)
@@ -81,11 +81,11 @@ namespace MGTools
    * There is no need to consider hanging nodes here, since only one level is
    * considered.
    */
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
-  make_sparsity_pattern (const DoFHandlerType           &dof_handler,
-                         SP                 &sparsity,
-                         const unsigned int level);
+  make_sparsity_pattern (const DoFHandlerType &dof_handler,
+                         SparsityPatternType  &sparsity,
+                         const unsigned int    level);
 
   /**
    * Make a sparsity pattern including fluxes of discontinuous Galerkin
@@ -95,11 +95,11 @@ namespace MGTools
    * and
    * @ref DoFTools
    */
-  template <int dim, class SP, int spacedim>
+  template <int dim, typename SparsityPatternType, int spacedim>
   void
   make_flux_sparsity_pattern (const DoFHandler<dim,spacedim> &dof_handler,
-                              SP                             &sparsity,
-                              const unsigned int             level);
+                              SparsityPatternType            &sparsity,
+                              const unsigned int              level);
 
   /**
    * Create sparsity pattern for the fluxes at refinement edges. The matrix
@@ -107,11 +107,11 @@ namespace MGTools
    *
    * make_flux_sparsity_pattern()
    */
-  template <int dim, class SP, int spacedim>
+  template <int dim, typename SparsityPatternType, int spacedim>
   void
   make_flux_sparsity_pattern_edge (const DoFHandler<dim,spacedim> &dof_handler,
-                                   SP                             &sparsity,
-                                   const unsigned int             level);
+                                   SparsityPatternType            &sparsity,
+                                   const unsigned int              level);
   /**
    * This function does the same as the other with the same name, but it gets
    * two additional coefficient matrices. A matrix entry will only be
@@ -121,11 +121,11 @@ namespace MGTools
    * There is one matrix for couplings in a cell and one for the couplings
    * occurring in fluxes.
    */
-  template <int dim, class SP, int spacedim>
+  template <int dim, typename SparsityPatternType, int spacedim>
   void
   make_flux_sparsity_pattern (const DoFHandler<dim,spacedim>    &dof,
-                              SP                                &sparsity,
-                              const unsigned int                level,
+                              SparsityPatternType               &sparsity,
+                              const unsigned int                 level,
                               const Table<2,DoFTools::Coupling> &int_mask,
                               const Table<2,DoFTools::Coupling> &flux_mask);
 
@@ -137,11 +137,11 @@ namespace MGTools
    *
    * make_flux_sparsity_pattern()
    */
-  template <int dim, class SP, int spacedim>
+  template <int dim, typename SparsityPatternType, int spacedim>
   void
   make_flux_sparsity_pattern_edge (const DoFHandler<dim,spacedim>    &dof_handler,
-                                   SP                                &sparsity,
-                                   const unsigned int                level,
+                                   SparsityPatternType               &sparsity,
+                                   const unsigned int                 level,
                                    const Table<2,DoFTools::Coupling> &flux_mask);
 
   /**
index 4527a7d26a5e608bd3fb413329e031490ffce807..aef8748d5549992de3d46729889f8d193bdaee5f 100644 (file)
@@ -49,10 +49,10 @@ namespace internal
     typedef ::dealii::SparsityPattern Sparsity;
     typedef ::dealii::SparseMatrix<typename VectorType::value_type> Matrix;
 
-    template <class DSP, typename DoFHandlerType>
-    static void reinit(Matrix &matrix, Sparsity &sparsity, int level, const DSP &dsp, const DoFHandlerType &)
+    template <typename SparsityPatternType, typename DoFHandlerType>
+    static void reinit(Matrix &matrix, Sparsity &sparsity, int level, const SparsityPatternType &sp, const DoFHandlerType &)
     {
-      sparsity.copy_from (dsp);
+      sparsity.copy_from (sp);
       (void)level;
       matrix.reinit (sparsity);
     }
@@ -65,12 +65,12 @@ namespace internal
     typedef ::dealii::TrilinosWrappers::SparsityPattern Sparsity;
     typedef ::dealii::TrilinosWrappers::SparseMatrix Matrix;
 
-    template <class DSP, typename DoFHandlerType>
-    static void reinit(Matrix &matrix, Sparsity &, int level, const DSP &dsp, DoFHandlerType &dh)
+    template <typename SparsityPatternType, typename DoFHandlerType>
+    static void reinit(Matrix &matrix, Sparsity &, int level, const SparsityPatternType &sp, DoFHandlerType &dh)
     {
       matrix.reinit(dh.locally_owned_mg_dofs(level+1),
                     dh.locally_owned_mg_dofs(level),
-                    dsp, MPI_COMM_WORLD, true);
+                    sp, MPI_COMM_WORLD, true);
     }
 
   };
@@ -80,12 +80,12 @@ namespace internal
     typedef ::dealii::TrilinosWrappers::SparsityPattern Sparsity;
     typedef ::dealii::TrilinosWrappers::SparseMatrix Matrix;
 
-    template <class DSP, typename DoFHandlerType>
-    static void reinit(Matrix &matrix, Sparsity &, int level, const DSP &dsp, DoFHandlerType &dh)
+    template <typename SparsityPatternType, typename DoFHandlerType>
+    static void reinit(Matrix &matrix, Sparsity &, int level, const SparsityPatternType &sp, DoFHandlerType &dh)
     {
       matrix.reinit(dh.locally_owned_mg_dofs(level+1),
                     dh.locally_owned_mg_dofs(level),
-                    dsp, MPI_COMM_WORLD, true);
+                    sp, MPI_COMM_WORLD, true);
     }
 
   };
@@ -96,8 +96,8 @@ namespace internal
     typedef ::dealii::TrilinosWrappers::SparsityPattern Sparsity;
     typedef ::dealii::TrilinosWrappers::SparseMatrix Matrix;
 
-    template <class DSP, typename DoFHandlerType>
-    static void reinit(Matrix &, Sparsity &, int /*level*/, const DSP &, DoFHandlerType &)
+    template <typename SparsityPatternType, typename DoFHandlerType>
+    static void reinit(Matrix &, Sparsity &, int /*level*/, const SparsityPatternType &, DoFHandlerType &)
     {
     }
   };
index 5954bfeba4c9f019e40886c92ab9525fedd586bd..58ff94eb73cf592ccb43670e7d265a216d259c95 100644 (file)
@@ -50,10 +50,10 @@ DEAL_II_NAMESPACE_OPEN
 namespace DoFTools
 {
 
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
   make_sparsity_pattern (const DoFHandlerType      &dof,
-                         SP                        &sparsity,
+                         SparsityPatternType       &sparsity,
                          const ConstraintMatrix    &constraints,
                          const bool                 keep_constrained_dofs,
                          const types::subdomain_id  subdomain_id)
@@ -109,11 +109,11 @@ namespace DoFTools
 
 
 
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
   make_sparsity_pattern (const DoFHandlerType      &dof,
                          const Table<2,Coupling>   &couplings,
-                         SP                        &sparsity,
+                         SparsityPatternType       &sparsity,
                          const ConstraintMatrix    &constraints,
                          const bool                 keep_constrained_dofs,
                          const types::subdomain_id  subdomain_id)
@@ -224,11 +224,11 @@ namespace DoFTools
 
 
 
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
   make_sparsity_pattern (const DoFHandlerType &dof_row,
                          const DoFHandlerType &dof_col,
-                         SP       &sparsity)
+                         SparsityPatternType  &sparsity)
   {
     const types::global_dof_index n_dofs_row = dof_row.n_dofs();
     const types::global_dof_index n_dofs_col = dof_col.n_dofs();
@@ -327,12 +327,12 @@ namespace DoFTools
 
 
 
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
   make_boundary_sparsity_pattern
   (const DoFHandlerType                       &dof,
    const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
-   SP                                         &sparsity)
+   SparsityPatternType                        &sparsity)
   {
     if (DoFHandlerType::dimension == 1)
       {
@@ -341,10 +341,11 @@ namespace DoFTools
         typename DoFHandlerType::FunctionMap boundary_ids;
         boundary_ids[0] = 0;
         boundary_ids[1] = 0;
-        make_boundary_sparsity_pattern<DoFHandlerType, SP> (dof,
-                                                            boundary_ids,
-                                                            dof_to_boundary_mapping,
-                                                            sparsity);
+        make_boundary_sparsity_pattern<DoFHandlerType, SparsityPatternType>
+        (dof,
+         boundary_ids,
+         dof_to_boundary_mapping,
+         sparsity);
         return;
       }
 
@@ -396,12 +397,12 @@ namespace DoFTools
 
 
 
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void make_boundary_sparsity_pattern
-  (const DoFHandlerType                                  &dof,
+  (const DoFHandlerType                                              &dof,
    const typename FunctionMap<DoFHandlerType::space_dimension>::type &boundary_ids,
-   const std::vector<types::global_dof_index>            &dof_to_boundary_mapping,
-   SP                                                    &sparsity)
+   const std::vector<types::global_dof_index>                        &dof_to_boundary_mapping,
+   SparsityPatternType                                               &sparsity)
   {
     if (DoFHandlerType::dimension == 1)
       {
@@ -484,10 +485,10 @@ namespace DoFTools
 
 
 
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
   make_flux_sparsity_pattern (const DoFHandlerType      &dof,
-                              SP                        &sparsity,
+                              SparsityPatternType       &sparsity,
                               const ConstraintMatrix    &constraints,
                               const bool                 keep_constrained_dofs,
                               const types::subdomain_id  subdomain_id)
@@ -634,10 +635,10 @@ namespace DoFTools
 
 
 
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
   make_flux_sparsity_pattern (const DoFHandlerType &dof,
-                              SP       &sparsity)
+                              SparsityPatternType  &sparsity)
   {
     ConstraintMatrix constraints;
     make_flux_sparsity_pattern (dof, sparsity, constraints);
@@ -710,10 +711,10 @@ namespace DoFTools
 
       // implementation of the same function in namespace DoFTools for
       // non-hp DoFHandlers
-      template <typename DoFHandlerType, class SP>
+      template <typename DoFHandlerType, typename SparsityPatternType>
       void
       make_flux_sparsity_pattern (const DoFHandlerType    &dof,
-                                  SP                      &sparsity,
+                                  SparsityPatternType     &sparsity,
                                   const Table<2,Coupling> &int_mask,
                                   const Table<2,Coupling> &flux_mask)
       {
@@ -942,10 +943,10 @@ namespace DoFTools
 
       // implementation of the same function in namespace DoFTools for
       // non-hp DoFHandlers
-      template <int dim, int spacedim, class SP>
+      template <int dim, int spacedim, typename SparsityPatternType>
       void
       make_flux_sparsity_pattern (const dealii::hp::DoFHandler<dim,spacedim> &dof,
-                                  SP                                         &sparsity,
+                                  SparsityPatternType                        &sparsity,
                                   const Table<2,Coupling>                    &int_mask,
                                   const Table<2,Coupling>                    &flux_mask)
       {
@@ -1131,10 +1132,10 @@ namespace DoFTools
 
 
 
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void
   make_flux_sparsity_pattern (const DoFHandlerType    &dof,
-                              SP                      &sparsity,
+                              SparsityPatternType     &sparsity,
                               const Table<2,Coupling> &int_mask,
                               const Table<2,Coupling> &flux_mask)
   {
index 2d61672c55e3fff78e1426300966c5565d90906b..1f31479a6130b481c5b587c0b9143ec8437080fb 100644 (file)
@@ -177,10 +177,10 @@ ChunkSparsityPattern::compress ()
 
 
 
-template <typename SparsityType>
+template <typename SparsityPatternType>
 void
-ChunkSparsityPattern::copy_from (const SparsityType &dsp,
-                                 const size_type     chunk_size)
+ChunkSparsityPattern::copy_from (const SparsityPatternType &dsp,
+                                 const size_type            chunk_size)
 {
   Assert (chunk_size > 0, ExcInvalidNumber (chunk_size));
   this->chunk_size = chunk_size;
@@ -208,7 +208,7 @@ ChunkSparsityPattern::copy_from (const SparsityType &dsp,
       // TODO: This could be made more efficient if we cached the
       // previous column and only called add() if the previous and the
       // current column lead to different chunk columns
-      for (typename SparsityType::iterator col_num = dsp.begin(row);
+      for (typename SparsityPatternType::iterator col_num = dsp.begin(row);
            col_num != dsp.end(row); ++col_num)
         temporary_sp.add (reduced_row, col_num->column()/chunk_size);
     }
@@ -276,9 +276,9 @@ namespace internal
 {
   namespace
   {
-    template <typename SP>
-    void copy_sparsity (const SP        &src,
-                        SparsityPattern &dst)
+    template <typename SparsityPatternType>
+    void copy_sparsity (const SparsityPatternType &src,
+                        SparsityPattern           &dst)
     {
       dst.copy_from(src);
     }
index 52f1523c2769d8fd0fcde81e0deb0547ba110b65..d105f489aba174644ac4da39dc76dcf0ee94e3b7 100644 (file)
@@ -1322,31 +1322,31 @@ BLOCK_MATRIX_VECTOR_FUNCTIONS(TrilinosWrappers::BlockSparseMatrix, TrilinosWrapp
 #endif
 
 
-#define SPARSITY_FUNCTIONS(SparsityType) \
-  template void ConstraintMatrix::add_entries_local_to_global<SparsityType> (\
-      const std::vector<ConstraintMatrix::size_type> &, \
-      SparsityType &,                    \
-      const bool,                        \
-      const Table<2,bool> &, \
-      internal::bool2type<false>) const; \
-  template void ConstraintMatrix::add_entries_local_to_global<SparsityType> (\
-      const std::vector<ConstraintMatrix::size_type> &, \
-      const std::vector<ConstraintMatrix::size_type> &, \
-      SparsityType &,                    \
-      const bool,                        \
+#define SPARSITY_FUNCTIONS(SparsityPatternType)                                      \
+  template void ConstraintMatrix::add_entries_local_to_global<SparsityPatternType> ( \
+      const std::vector<ConstraintMatrix::size_type> &,                              \
+      SparsityPatternType &,                                                         \
+      const bool,                                                                    \
+      const Table<2,bool> &,                                                         \
+      internal::bool2type<false>) const;                                             \
+  template void ConstraintMatrix::add_entries_local_to_global<SparsityPatternType> ( \
+      const std::vector<ConstraintMatrix::size_type> &,                              \
+      const std::vector<ConstraintMatrix::size_type> &,                              \
+      SparsityPatternType &,                                                         \
+      const bool,                                                                    \
       const Table<2,bool> &) const
-#define BLOCK_SPARSITY_FUNCTIONS(SparsityType) \
-  template void ConstraintMatrix::add_entries_local_to_global<SparsityType> (\
-      const std::vector<ConstraintMatrix::size_type> &, \
-      SparsityType &,                    \
-      const bool,                        \
-      const Table<2,bool> &, \
-      internal::bool2type<true>) const; \
-  template void ConstraintMatrix::add_entries_local_to_global<SparsityType> (\
-      const std::vector<ConstraintMatrix::size_type> &, \
-      const std::vector<ConstraintMatrix::size_type> &, \
-      SparsityType &,                    \
-      const bool,                        \
+#define BLOCK_SPARSITY_FUNCTIONS(SparsityPatternType)                                \
+  template void ConstraintMatrix::add_entries_local_to_global<SparsityPatternType> ( \
+      const std::vector<ConstraintMatrix::size_type> &,                              \
+      SparsityPatternType &,                                                         \
+      const bool,                                                                    \
+      const Table<2,bool> &,                                                         \
+      internal::bool2type<true>) const;                                              \
+  template void ConstraintMatrix::add_entries_local_to_global<SparsityPatternType> ( \
+      const std::vector<ConstraintMatrix::size_type> &,                              \
+      const std::vector<ConstraintMatrix::size_type> &,                              \
+      SparsityPatternType &,                                                         \
+      const bool,                                                                    \
       const Table<2,bool> &) const
 
 SPARSITY_FUNCTIONS(SparsityPattern);
index ba9d281a72d440b44733d2f9d66b00926ceddefc..e71162fef212b7c345a1d764be921908a3282d4c 100644 (file)
@@ -88,10 +88,10 @@ namespace PETScWrappers
 
 
 
-    template <typename SparsityType>
+    template <typename SparsityPatternType>
     SparseMatrix::
     SparseMatrix (const MPI_Comm               &communicator,
-                  const SparsityType           &sparsity_pattern,
+                  const SparsityPatternType    &sparsity_pattern,
                   const std::vector<size_type> &local_rows_per_process,
                   const std::vector<size_type> &local_columns_per_process,
                   const unsigned int            this_process,
@@ -201,11 +201,11 @@ namespace PETScWrappers
 
 
 
-    template <typename SparsityType>
+    template <typename SparsityPatternType>
     void
     SparseMatrix::
     reinit (const MPI_Comm               &communicator,
-            const SparsityType           &sparsity_pattern,
+            const SparsityPatternType    &sparsity_pattern,
             const std::vector<size_type> &local_rows_per_process,
             const std::vector<size_type> &local_columns_per_process,
             const unsigned int            this_process,
@@ -227,13 +227,13 @@ namespace PETScWrappers
                  preset_nonzero_locations);
     }
 
-    template <typename SparsityType>
+    template <typename SparsityPatternType>
     void
     SparseMatrix::
-    reinit (const IndexSet &local_rows,
-            const IndexSet &local_columns,
-            const SparsityType &sparsity_pattern,
-            const MPI_Comm &communicator)
+    reinit (const IndexSet            &local_rows,
+            const IndexSet            &local_columns,
+            const SparsityPatternType &sparsity_pattern,
+            const MPI_Comm            &communicator)
     {
       this->communicator = communicator;
 
@@ -385,12 +385,12 @@ namespace PETScWrappers
     }
 
 
-    template <typename SparsityType>
+    template <typename SparsityPatternType>
     void
     SparseMatrix::
-    do_reinit (const IndexSet &local_rows,
-               const IndexSet &local_columns,
-               const SparsityType         &sparsity_pattern)
+    do_reinit (const IndexSet            &local_rows,
+               const IndexSet            &local_columns,
+               const SparsityPatternType &sparsity_pattern)
     {
       Assert(sparsity_pattern.n_rows()==local_rows.size(),
              ExcMessage("SparsityPattern and IndexSet have different number of rows"));
@@ -472,7 +472,7 @@ namespace PETScWrappers
           {
             PetscInt *ptr = & colnums_in_window[0];
             for (PetscInt i=local_row_start; i<local_row_end; ++i)
-              for (typename SparsityType::iterator p=sparsity_pattern.begin(i);
+              for (typename SparsityPatternType::iterator p=sparsity_pattern.begin(i);
                    p != sparsity_pattern.end(i); ++p, ++ptr)
                 *ptr = p->column();
           }
@@ -546,10 +546,10 @@ namespace PETScWrappers
     }
 
 
-    template <typename SparsityType>
+    template <typename SparsityPatternType>
     void
     SparseMatrix::
-    do_reinit (const SparsityType           &sparsity_pattern,
+    do_reinit (const SparsityPatternType    &sparsity_pattern,
                const std::vector<size_type> &local_rows_per_process,
                const std::vector<size_type> &local_columns_per_process,
                const unsigned int            this_process,
@@ -693,7 +693,7 @@ namespace PETScWrappers
           {
             PetscInt *ptr = & colnums_in_window[0];
             for (size_type i=local_row_start; i<local_row_end; ++i)
-              for (typename SparsityType::iterator p=sparsity_pattern.begin(i);
+              for (typename SparsityPatternType::iterator p=sparsity_pattern.begin(i);
                    p != sparsity_pattern.end(i); ++p, ++ptr)
                 *ptr = p->column();
           }
index ba84fc51d59f4d392a238d84c845bddf004bca18..22c577252fd30846fdcaf31384457b5710e473f2 100644 (file)
@@ -57,10 +57,10 @@ namespace PETScWrappers
 
 
 
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   SparseMatrix::
-  SparseMatrix (const SparsityType &sparsity_pattern,
-                const bool          preset_nonzero_locations)
+  SparseMatrix (const SparsityPatternType &sparsity_pattern,
+                const bool                 preset_nonzero_locations)
   {
     do_reinit (sparsity_pattern, preset_nonzero_locations);
   }
@@ -116,11 +116,11 @@ namespace PETScWrappers
 
 
 
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   void
   SparseMatrix::
-  reinit (const SparsityType &sparsity_pattern,
-          const bool          preset_nonzero_locations)
+  reinit (const SparsityPatternType &sparsity_pattern,
+          const bool                 preset_nonzero_locations)
   {
     // get rid of old matrix and generate a
     // new one
@@ -219,10 +219,10 @@ namespace PETScWrappers
 
 
 
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   void
-  SparseMatrix::do_reinit (const SparsityType &sparsity_pattern,
-                           const bool          preset_nonzero_locations)
+  SparseMatrix::do_reinit (const SparsityPatternType &sparsity_pattern,
+                           const bool                 preset_nonzero_locations)
   {
     std::vector<size_type> row_lengths (sparsity_pattern.n_rows());
     for (size_type i=0; i<sparsity_pattern.n_rows(); ++i)
index e2b345939bbee109510b7544098e9566a6a0d4ce..070a846457f47460d165a18a6e6be1609abbafce 100644 (file)
@@ -480,9 +480,9 @@ SparsityPattern::compress ()
 
 
 
-template <typename DSP>
+template <typename SparsityPatternType>
 void
-SparsityPattern::copy_from (const DSP &dsp)
+SparsityPattern::copy_from (const SparsityPatternType &dsp)
 {
   // first determine row lengths for each row. if the matrix is quadratic,
   // then we might have to add an additional entry for the diagonal, if that
@@ -505,8 +505,8 @@ SparsityPattern::copy_from (const DSP &dsp)
     for (size_type row = 0; row<dsp.n_rows(); ++row)
       {
         size_type *cols = &colnums[rowstart[row]] + (do_diag_optimize ? 1 : 0);
-        typename DSP::iterator col_num = dsp.begin (row),
-                               end_row = dsp.end (row);
+        typename SparsityPatternType::iterator col_num = dsp.begin (row),
+                                               end_row = dsp.end (row);
 
         for (; col_num != end_row; ++col_num)
           {
@@ -517,7 +517,8 @@ SparsityPattern::copy_from (const DSP &dsp)
       }
 
   // do not need to compress the sparsity pattern since we already have
-  // allocated the right amount of data, and the DSP data is sorted, too.
+  // allocated the right amount of data, and the SparsityPatternType data is sorted,
+  // too.
   compressed = true;
 }
 
index fc8ebc21f6eac22ff79765cbc804356597ea7cbe..1b6d80151c64cf82ea525873998515bad1ae141a 100644 (file)
@@ -79,12 +79,12 @@ namespace TrilinosWrappers
 
 
 
-  template <typename BlockSparsityType>
+  template <typename BlockSparsityPatternType>
   void
   BlockSparseMatrix::
-  reinit (const std::vector<Epetra_Map> &parallel_partitioning,
-          const BlockSparsityType       &block_sparsity_pattern,
-          const bool                   exchange_data)
+  reinit (const std::vector<Epetra_Map>  &parallel_partitioning,
+          const BlockSparsityPatternType &block_sparsity_pattern,
+          const bool                      exchange_data)
   {
     Assert (parallel_partitioning.size() == block_sparsity_pattern.n_block_rows(),
             ExcDimensionMismatch (parallel_partitioning.size(),
@@ -126,13 +126,13 @@ namespace TrilinosWrappers
 
 
 
-  template <typename BlockSparsityType>
+  template <typename BlockSparsityPatternType>
   void
   BlockSparseMatrix::
-  reinit (const std::vector<IndexSet> &parallel_partitioning,
-          const BlockSparsityType     &block_sparsity_pattern,
-          const MPI_Comm              &communicator,
-          const bool                   exchange_data)
+  reinit (const std::vector<IndexSet>    &parallel_partitioning,
+          const BlockSparsityPatternType &block_sparsity_pattern,
+          const MPI_Comm                 &communicator,
+          const bool                      exchange_data)
   {
     std::vector<Epetra_Map> epetra_maps;
     for (size_type i=0; i<block_sparsity_pattern.n_block_rows(); ++i)
@@ -145,10 +145,10 @@ namespace TrilinosWrappers
 
 
 
-  template <typename BlockSparsityType>
+  template <typename BlockSparsityPatternType>
   void
   BlockSparseMatrix::
-  reinit (const BlockSparsityType &block_sparsity_pattern)
+  reinit (const BlockSparsityPatternType &block_sparsity_pattern)
   {
     std::vector<Epetra_Map> parallel_partitioning;
     for (size_type i=0; i<block_sparsity_pattern.n_block_rows(); ++i)
index f1f6edd5f77a967043503c390deb9c07c0059665..ba82179ff5405356d6d68b47b81a8f67ace519e4 100644 (file)
@@ -454,11 +454,11 @@ namespace TrilinosWrappers
   {
     typedef SparseMatrix::size_type size_type;
 
-    template <typename SparsityType>
+    template <typename SparsityPatternType>
     void
     reinit_matrix (const Epetra_Map                          &input_row_map,
                    const Epetra_Map                          &input_col_map,
-                   const SparsityType                        &sparsity_pattern,
+                   const SparsityPatternType                 &sparsity_pattern,
                    const bool                                 exchange_data,
                    std_cxx11::shared_ptr<Epetra_Map>         &column_space_map,
                    std_cxx11::shared_ptr<Epetra_FECrsMatrix> &matrix,
@@ -539,7 +539,7 @@ namespace TrilinosWrappers
 
           row_indices.resize (row_length, -1);
           {
-            typename SparsityType::iterator p = sparsity_pattern.begin(row);
+            typename SparsityPatternType::iterator p = sparsity_pattern.begin(row);
             for (size_type col=0; p != sparsity_pattern.end(row); ++p, ++col)
               row_indices[col] = p->column();
           }
@@ -741,9 +741,9 @@ namespace TrilinosWrappers
 
 
 
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   void
-  SparseMatrix::reinit (const SparsityType &sparsity_pattern)
+  SparseMatrix::reinit (const SparsityPatternType &sparsity_pattern)
   {
     const Epetra_Map rows (static_cast<TrilinosWrappers::types::int_type>(sparsity_pattern.n_rows()),
                            0,
@@ -759,11 +759,11 @@ namespace TrilinosWrappers
 
 
 
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   void
-  SparseMatrix::reinit (const Epetra_Map    &input_map,
-                        const SparsityType  &sparsity_pattern,
-                        const bool           exchange_data)
+  SparseMatrix::reinit (const Epetra_Map          &input_map,
+                        const SparsityPatternType &sparsity_pattern,
+                        const bool                 exchange_data)
   {
     reinit_matrix (input_map, input_map, sparsity_pattern, exchange_data,
                    column_space_map, matrix, nonlocal_matrix,
@@ -775,13 +775,13 @@ namespace TrilinosWrappers
 
 
 
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   inline
-  void SparseMatrix::reinit (const IndexSet      &row_parallel_partitioning,
-                             const IndexSet      &col_parallel_partitioning,
-                             const SparsityType  &sparsity_pattern,
-                             const MPI_Comm      &communicator,
-                             const bool           exchange_data)
+  void SparseMatrix::reinit (const IndexSet            &row_parallel_partitioning,
+                             const IndexSet            &col_parallel_partitioning,
+                             const SparsityPatternType &sparsity_pattern,
+                             const MPI_Comm            &communicator,
+                             const bool                 exchange_data)
   {
     Epetra_Map row_map =
       row_parallel_partitioning.make_trilinos_map (communicator, false);
@@ -799,12 +799,12 @@ namespace TrilinosWrappers
 
 
 
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   inline
-  void SparseMatrix::reinit (const Epetra_Map    &row_map,
-                             const Epetra_Map    &col_map,
-                             const SparsityType  &sparsity_pattern,
-                             const bool           exchange_data)
+  void SparseMatrix::reinit (const Epetra_Map          &row_map,
+                             const Epetra_Map          &col_map,
+                             const SparsityPatternType &sparsity_pattern,
+                             const bool                 exchange_data)
   {
     reinit_matrix (row_map, col_map, sparsity_pattern, exchange_data,
                    column_space_map, matrix, nonlocal_matrix,
index 9a3ca88d72fd44f27aaa35caec3492d10d695dd7..76386a4b8354d47891ccc28aaee6943cb08be8f0 100644 (file)
@@ -428,11 +428,11 @@ namespace TrilinosWrappers
 
 
 
-    template <typename SparsityType>
+    template <typename SparsityPatternType>
     void
     reinit_sp (const Epetra_Map                         &row_map,
                const Epetra_Map                         &col_map,
-               const SparsityType                       &sp,
+               const SparsityPatternType                &sp,
                const bool                                exchange_data,
                std_cxx11::shared_ptr<Epetra_Map>        &column_space_map,
                std_cxx11::shared_ptr<Epetra_FECrsGraph> &graph,
@@ -485,7 +485,7 @@ namespace TrilinosWrappers
 
             row_indices.resize (row_length, -1);
             {
-              typename SparsityType::iterator p = sp.begin(row);
+              typename SparsityPatternType::iterator p = sp.begin(row);
               // avoid incrementing p over the end of the current row because
               // it is slow for DynamicSparsityPattern in parallel
               for (int col=0; col<row_length; )
@@ -507,7 +507,7 @@ namespace TrilinosWrappers
 
             row_indices.resize (row_length, -1);
             {
-              typename SparsityType::iterator p = sp.begin(row);
+              typename SparsityPatternType::iterator p = sp.begin(row);
               // avoid incrementing p over the end of the current row because
               // it is slow for DynamicSparsityPattern in parallel
               for (int col=0; col<row_length; )
@@ -669,13 +669,13 @@ namespace TrilinosWrappers
 
 
 
-  template<typename SparsityType>
+  template<typename SparsityPatternType>
   void
-  SparsityPattern::reinit (const IndexSet     &row_parallel_partitioning,
-                           const IndexSet     &col_parallel_partitioning,
-                           const SparsityType &nontrilinos_sparsity_pattern,
-                           const MPI_Comm     &communicator,
-                           const bool          exchange_data)
+  SparsityPattern::reinit (const IndexSet            &row_parallel_partitioning,
+                           const IndexSet            &col_parallel_partitioning,
+                           const SparsityPatternType &nontrilinos_sparsity_pattern,
+                           const MPI_Comm            &communicator,
+                           const bool                 exchange_data)
   {
     Epetra_Map row_map =
       row_parallel_partitioning.make_trilinos_map (communicator, false);
@@ -687,12 +687,12 @@ namespace TrilinosWrappers
 
 
 
-  template<typename SparsityType>
+  template<typename SparsityPatternType>
   void
-  SparsityPattern::reinit (const IndexSet     &parallel_partitioning,
-                           const SparsityType &nontrilinos_sparsity_pattern,
-                           const MPI_Comm     &communicator,
-                           const bool          exchange_data)
+  SparsityPattern::reinit (const IndexSet            &parallel_partitioning,
+                           const SparsityPatternType &nontrilinos_sparsity_pattern,
+                           const MPI_Comm            &communicator,
+                           const bool                 exchange_data)
   {
     Epetra_Map map = parallel_partitioning.make_trilinos_map (communicator,
                                                               false);
@@ -702,11 +702,11 @@ namespace TrilinosWrappers
 
 
 
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   void
-  SparsityPattern::reinit (const Epetra_Map   &input_map,
-                           const SparsityType &sp,
-                           const bool          exchange_data)
+  SparsityPattern::reinit (const Epetra_Map          &input_map,
+                           const SparsityPatternType &sp,
+                           const bool                 exchange_data)
   {
     reinit_sp (input_map, input_map, sp, exchange_data,
                column_space_map, graph, nonlocal_graph);
@@ -714,12 +714,12 @@ namespace TrilinosWrappers
 
 
 
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   void
-  SparsityPattern::reinit (const Epetra_Map   &input_row_map,
-                           const Epetra_Map   &input_col_map,
-                           const SparsityType &sp,
-                           const bool          exchange_data)
+  SparsityPattern::reinit (const Epetra_Map          &input_row_map,
+                           const Epetra_Map          &input_col_map,
+                           const SparsityPatternType &sp,
+                           const bool                 exchange_data)
   {
     reinit_sp (input_row_map, input_col_map, sp, exchange_data,
                column_space_map, graph, nonlocal_graph);
@@ -738,9 +738,9 @@ namespace TrilinosWrappers
 
 
 
-  template <typename SparsityType>
+  template <typename SparsityPatternType>
   void
-  SparsityPattern::copy_from (const SparsityType &sp)
+  SparsityPattern::copy_from (const SparsityPatternType &sp)
   {
     const Epetra_Map rows (TrilinosWrappers::types::int_type(sp.n_rows()), 0,
                            Utilities::Trilinos::comm_self());
index 1add14de02d6f1402d142bd8a9922ab15c193305..a1d9df09f375f7c91da79207820bc8aa639daac1 100644 (file)
@@ -535,9 +535,9 @@ namespace MGTools
 
 
 
-  template <typename DoFHandlerType, class SP>
+  template <typename DoFHandlerType, typename SparsityPatternType>
   void make_sparsity_pattern (const DoFHandlerType &dof,
-                              SP                   &sparsity,
+                              SparsityPatternType  &sparsity,
                               const unsigned int    level)
   {
     const types::global_dof_index n_dofs = dof.n_dofs(level);
@@ -567,10 +567,10 @@ namespace MGTools
 
 
 
-  template <int dim, class SP, int spacedim>
+  template <int dim, typename SparsityPatternType, int spacedim>
   void
   make_flux_sparsity_pattern (const DoFHandler<dim,spacedim> &dof,
-                              SP                             &sparsity,
+                              SparsityPatternType            &sparsity,
                               const unsigned int              level)
   {
     const types::global_dof_index n_dofs = dof.n_dofs(level);
@@ -635,10 +635,10 @@ namespace MGTools
 
 
 
-  template <int dim, class SP, int spacedim>
+  template <int dim, typename SparsityPatternType, int spacedim>
   void
   make_flux_sparsity_pattern_edge (const DoFHandler<dim,spacedim> &dof,
-                                   SP                             &sparsity,
+                                   SparsityPatternType            &sparsity,
                                    const unsigned int              level)
   {
     Assert ((level>=1) && (level<dof.get_tria().n_global_levels()),
@@ -697,10 +697,10 @@ namespace MGTools
 
 
 
-  template <int dim, class SP, int spacedim>
+  template <int dim, typename SparsityPatternType, int spacedim>
   void
   make_flux_sparsity_pattern (const DoFHandler<dim,spacedim>    &dof,
-                              SP                                &sparsity,
+                              SparsityPatternType               &sparsity,
                               const unsigned int                 level,
                               const Table<2,DoFTools::Coupling> &int_mask,
                               const Table<2,DoFTools::Coupling> &flux_mask)
@@ -877,10 +877,10 @@ namespace MGTools
 
 
 
-  template <int dim, class SP, int spacedim>
+  template <int dim, typename SparsityPatternType, int spacedim>
   void
   make_flux_sparsity_pattern_edge (const DoFHandler<dim,spacedim>    &dof,
-                                   SP                                &sparsity,
+                                   SparsityPatternType               &sparsity,
                                    const unsigned int                 level,
                                    const Table<2,DoFTools::Coupling> &flux_mask)
   {

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.