]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Convert unvalid_unsigned_int to unvalid_dof_index.
authorturcksin <turcksin@0785d39b-7218-0410-832d-ea1e28bc413d>
Fri, 15 Mar 2013 22:36:54 +0000 (22:36 +0000)
committerturcksin <turcksin@0785d39b-7218-0410-832d-ea1e28bc413d>
Fri, 15 Mar 2013 22:36:54 +0000 (22:36 +0000)
git-svn-id: https://svn.dealii.org/branches/branch_bigger_global_dof_indices_4@28917 0785d39b-7218-0410-832d-ea1e28bc413d

25 files changed:
deal.II/include/deal.II/base/index_set.h
deal.II/include/deal.II/base/partitioner.h
deal.II/include/deal.II/base/types.h
deal.II/include/deal.II/dofs/dof_accessor.templates.h
deal.II/include/deal.II/dofs/dof_handler.h
deal.II/include/deal.II/hp/dof_handler.h
deal.II/include/deal.II/hp/dof_objects.h
deal.II/include/deal.II/lac/block_vector_base.h
deal.II/include/deal.II/lac/constraint_matrix.h
deal.II/include/deal.II/lac/matrix_block.h
deal.II/include/deal.II/lac/parallel_vector.templates.h
deal.II/include/deal.II/lac/relaxation_block.templates.h
deal.II/include/deal.II/lac/sparse_ilu.templates.h
deal.II/include/deal.II/matrix_free/dof_info.h
deal.II/include/deal.II/numerics/vector_tools.templates.h
deal.II/source/base/partitioner.cc
deal.II/source/dofs/dof_renumbering.cc
deal.II/source/dofs/dof_tools.cc
deal.II/source/hp/dof_handler.cc
deal.II/source/lac/sparsity_pattern.cc
deal.II/source/lac/sparsity_tools.cc
deal.II/source/multigrid/mg_transfer_block.cc
deal.II/source/multigrid/mg_transfer_component.cc
deal.II/source/multigrid/mg_transfer_prebuilt.cc
deal.II/source/numerics/matrix_tools.cc

index 379408dc1db0701f9800bbbbf630457340fb852a..e2a96ceb39a50811ac448975dc16d4857fde2dab 100644 (file)
@@ -84,7 +84,7 @@ public:
    * This can be achieved by calling
    * clear(), for example.
    */
-  void set_size (const unsigned int size);
+  void set_size (const types::global_dof_index size);
 
   /**
    * Return the size of the index
@@ -96,7 +96,7 @@ public:
    * set. The latter information is
    * returned by n_elements().
    */
-  unsigned int size () const;
+  types::global_dof_index size () const;
 
   /**
    * Add the half-open range
@@ -534,7 +534,7 @@ private:
    * set have to have a smaller
    * number than this value.
    */
-  unsigned int index_space_size;
+  types::global_dof_index index_space_size;
 
   /**
    * This integer caches the index of the
@@ -566,8 +566,8 @@ private:
 inline
 IndexSet::Range::Range ()
   :
-  begin(numbers::invalid_unsigned_int),
-  end(numbers::invalid_unsigned_int)
+  begin(numbers::invalid_dof_index),
+  end(numbers::invalid_dof_index)
 {}
 
 
@@ -612,7 +612,7 @@ IndexSet::clear ()
 
 inline
 void
-IndexSet::set_size (const unsigned int sz)
+IndexSet::set_size (const types::global_dof_index sz)
 {
   Assert (ranges.empty(),
           ExcMessage ("This function can only be called if the current "
@@ -624,7 +624,7 @@ IndexSet::set_size (const unsigned int sz)
 
 
 inline
-unsigned int
+types::global_dof_index
 IndexSet::size () const
 {
   return index_space_size;
@@ -901,7 +901,7 @@ IndexSet::nth_index_in_set (const unsigned int n) const
   else
     {
       Assert (false, ExcInternalError());
-      return numbers::invalid_unsigned_int;
+      return numbers::invalid_dof_index;
     }
 }
 
index 614ee08154c6f525c8bab3d936ba51c7cb7086e1..736a238499369f12345603e453e71b91c2f07941 100644 (file)
@@ -215,7 +215,7 @@ namespace Utilities
        * but tailored to be iterated over, and some
        * indices may be duplicates.
        */
-      const std::vector<std::pair<unsigned int, types::global_dof_index> > &
+      const std::vector<std::pair<types::global_dof_index, types::global_dof_index> > &
       import_indices() const;
 
       /**
@@ -335,7 +335,7 @@ namespace Utilities
        * but tailored to be iterated over, and some
        * indices may be duplicates.
        */
-      std::vector<std::pair<unsigned int, types::global_dof_index> > import_indices_data;
+      std::vector<std::pair<types::global_dof_index, types::global_dof_index> > import_indices_data;
 
       /**
        * Caches the number of ghost indices. It
@@ -495,7 +495,7 @@ namespace Utilities
 
 
     inline
-    const std::vector<std::pair<unsigned int, types::global_dof_index> > &
+    const std::vector<std::pair<types::global_dof_index, types::global_dof_index> > &
     Partitioner::import_indices() const
     {
       return import_indices_data;
index 544178d1720b0c53bea2acee0f3198192fb61dfc..2e4c516020baa2a634b5d84e67bec57f3958b520 100644 (file)
@@ -52,7 +52,7 @@ namespace types
    */
   const unsigned int artificial_subdomain_id DEAL_II_DEPRECATED = static_cast<subdomain_id>(-2);
 
-//#define DEAL_II_USE_LARGE_INDEX_TYPE
+#define DEAL_II_USE_LARGE_INDEX_TYPE
 #ifdef DEAL_II_USE_LARGE_INDEX_TYPE
   /**
    * The type used for global indices of
index 7f15e6c2872702180be226cd67c1bac2c05c272f..dfe57da782d750a42db841ba368571e822ea9ba9 100644 (file)
@@ -1144,7 +1144,7 @@ namespace internal
         Assert (fe_index < dof_handler.finite_elements->size(),
                 ExcInternalError());
         Assert (dof_handler.vertex_dofs_offsets[vertex_index] !=
-                numbers::invalid_unsigned_int,
+                numbers::invalid_dof_index,
                 ExcMessage ("This vertex is unused and has no DoFs associated with it"));
 
         // hop along the list of index
@@ -1154,7 +1154,7 @@ namespace internal
         // part. trigger an exception if
         // we can't find a set for this
         // particular fe_index
-        const unsigned int starting_offset = dof_handler.vertex_dofs_offsets[vertex_index];
+        const types::global_dof_index starting_offset = dof_handler.vertex_dofs_offsets[vertex_index];
         types::global_dof_index *pointer = &dof_handler.vertex_dofs[starting_offset];
         while (true)
           {
@@ -1236,7 +1236,7 @@ namespace internal
                 ExcIndexRange (vertex_index, 0,
                                dof_handler.vertex_dofs_offsets.size()));
         Assert (dof_handler.vertex_dofs_offsets[vertex_index] !=
-                numbers::invalid_unsigned_int,
+                numbers::invalid_dof_index,
                 ExcMessage ("This vertex is unused and has no DoFs associated with it"));
 
         // hop along the list of index
@@ -1285,16 +1285,16 @@ namespace internal
                             "this DoFHandler"));
 
         // if this vertex is unused, return 0
-        if (dof_handler.vertex_dofs_offsets[vertex_index] == numbers::invalid_unsigned_int)
+        if (dof_handler.vertex_dofs_offsets[vertex_index] == numbers::invalid_dof_index)
           return 0;
 
         // hop along the list of index
         // sets and count the number of
         // hops
-        const unsigned int starting_offset = dof_handler.vertex_dofs_offsets[vertex_index];
+        const types::global_dof_index starting_offset = dof_handler.vertex_dofs_offsets[vertex_index];
         const types::global_dof_index *pointer = &dof_handler.vertex_dofs[starting_offset];
 
-        Assert (*pointer != numbers::invalid_size_type,
+        Assert (*pointer != numbers::invalid_dof_index,
                 ExcInternalError());
 
         unsigned int counter = 0;
@@ -1338,16 +1338,16 @@ namespace internal
         // make sure we don't ask on
         // unused vertices
         Assert (dof_handler.vertex_dofs_offsets[vertex_index] !=
-                numbers::invalid_unsigned_int,
+                numbers::invalid_dof_index,
                 ExcInternalError());
 
         // hop along the list of index
         // sets and count the number of
         // hops
-        const unsigned int starting_offset = dof_handler.vertex_dofs_offsets[vertex_index];
+        const types::global_dof_index starting_offset = dof_handler.vertex_dofs_offsets[vertex_index];
         const types::global_dof_index *pointer = &dof_handler.vertex_dofs[starting_offset];
 
-        Assert (*pointer != numbers::invalid_unsigned_int,
+        Assert (*pointer != numbers::invalid_dof_index,
                 ExcInternalError());
 
         unsigned int counter = 0;
@@ -1399,23 +1399,23 @@ namespace internal
         // make sure we don't ask on
         // unused vertices
         Assert (dof_handler.vertex_dofs_offsets[vertex_index] !=
-                numbers::invalid_unsigned_int,
+                numbers::invalid_dof_index,
                 ExcInternalError());
 
         // hop along the list of index
         // sets and see whether we find
         // the given index
-        const unsigned int starting_offset = dof_handler.vertex_dofs_offsets[vertex_index];
+        const types::global_dof_index starting_offset = dof_handler.vertex_dofs_offsets[vertex_index];
         const types::global_dof_index *pointer = &dof_handler.vertex_dofs[starting_offset];
 
-        Assert (*pointer != numbers::invalid_unsigned_int,
+        Assert (*pointer != numbers::invalid_dof_index,
                 ExcInternalError());
 
         while (true)
           {
             Assert (pointer <= &dof_handler.vertex_dofs.back(), ExcInternalError());
 
-            Assert((*pointer)<std::numeric_limits<unsigned int>::max(), ExcInternalError());
+            Assert((*pointer)<std::numeric_limits<types::global_dof_index>::max(), ExcInternalError());
             const unsigned int this_fe_index = static_cast<unsigned int>(*pointer);
 
             Assert (this_fe_index < dof_handler.finite_elements->size(),
@@ -1815,7 +1815,7 @@ namespace internal
                              const unsigned int fe_index)
     {
       const DH &handler = accessor.get_dof_handler();
-      Assert(handler.n_dofs(level) != numbers::invalid_unsigned_int,
+      Assert(handler.n_dofs(level) != numbers::invalid_dof_index,
              ExcNotInitialized());
 
       const FiniteElement<DH::dimension, DH::space_dimension> &fe
@@ -1841,7 +1841,7 @@ namespace internal
                              const unsigned int fe_index)
     {
       const DH &handler = accessor.get_dof_handler();
-      Assert(handler.n_dofs(level) != numbers::invalid_unsigned_int,
+      Assert(handler.n_dofs(level) != numbers::invalid_dof_index,
              ExcNotInitialized());
 
       const FiniteElement<DH::dimension, DH::space_dimension> &fe = handler.get_fe ()[fe_index];
@@ -1870,7 +1870,7 @@ namespace internal
                              const unsigned int fe_index)
     {
       const DH &handler = accessor.get_dof_handler();
-      Assert(handler.n_dofs(level) != numbers::invalid_unsigned_int,
+      Assert(handler.n_dofs(level) != numbers::invalid_dof_index,
              ExcNotInitialized());
 
       const FiniteElement<DH::dimension, DH::space_dimension> &fe = handler.get_fe ()[fe_index];
index 0c3e86b613eedfc89632c5ff05c7a3ccc5110c8e..16bd808a8accc65cae9bc8d3f89e6cdc7ad1f830 100644 (file)
@@ -613,7 +613,7 @@ public:
    * If no level degrees of
    * freedom have been assigned
    * to this level, returns
-   * numbers::invalid_unsigned_int. Else
+   * numbers::invalid_dof_index. Else
    * returns the number of
    * degrees of freedom on this level.
    */
index 1581eeddd405f6b89ec8ba029c06df6af9b7bd99..e9ae42763ae16865f6e62e169c2b2bea212c75b4 100644 (file)
@@ -849,7 +849,7 @@ namespace hp
      * actual data format used to
      * the present class.
      */
-    std::vector<unsigned int>      vertex_dofs_offsets;
+    std::vector<types::global_dof_index>      vertex_dofs_offsets;
 
     std::vector<MGVertexDoFs> mg_vertex_dofs;
 
@@ -915,7 +915,7 @@ namespace hp
   types::global_dof_index
   DoFHandler<dim,spacedim>::n_dofs (const unsigned int) const
   {
-    return numbers::invalid_unsigned_int;
+    return numbers::invalid_dof_index;
   }
 
 
index 145f394faa6fb5cc7121d5b69919a7e5fbfa98a1..3c938ef24ec8a74a605563135c7ae090028be0a2 100644 (file)
@@ -272,7 +272,7 @@ namespace internal
       // make sure we are on an
       // object for which DoFs have
       // been allocated at all
-      Assert (dof_offsets[obj_index] != numbers::invalid_unsigned_int,
+      Assert (dof_offsets[obj_index] != numbers::invalid_dof_index,
               ExcMessage ("You are trying to access degree of freedom "
                           "information for an object on which no such "
                           "information is available"));
@@ -308,7 +308,7 @@ namespace internal
           const types::global_dof_index *pointer        = &dofs[starting_offset];
           while (true)
             {
-              Assert (*pointer != numbers::invalid_unsigned_int,
+              Assert (*pointer != numbers::invalid_dof_index,
                       ExcInternalError());
               if (*pointer == fe_index)
                 return *(pointer + 1 + local_index);
@@ -354,7 +354,7 @@ namespace internal
       // make sure we are on an
       // object for which DoFs have
       // been allocated at all
-      Assert (dof_offsets[obj_index] != numbers::invalid_unsigned_int,
+      Assert (dof_offsets[obj_index] != numbers::invalid_dof_index,
               ExcMessage ("You are trying to access degree of freedom "
                           "information for an object on which no such "
                           "information is available"));
@@ -390,7 +390,7 @@ namespace internal
           types::global_dof_index      *pointer         = &dofs[starting_offset];
           while (true)
             {
-              Assert (*pointer != numbers::invalid_unsigned_int,
+              Assert (*pointer != numbers::invalid_dof_index,
                       ExcInternalError());
               if (*pointer == fe_index)
                 {
@@ -426,7 +426,7 @@ namespace internal
       // make sure we are on an
       // object for which DoFs have
       // been allocated at all
-      if (dof_offsets[obj_index] == numbers::invalid_unsigned_int)
+      if (dof_offsets[obj_index] == numbers::invalid_dof_index)
         return 0;
 
       // if we are on a cell, then the
@@ -454,7 +454,7 @@ namespace internal
           unsigned int counter = 0;
           while (true)
             {
-              if (*pointer == numbers::invalid_unsigned_int)
+              if (*pointer == numbers::invalid_dof_index)
                 // end of list reached
                 return counter;
               else
@@ -491,7 +491,7 @@ namespace internal
       // make sure we are on an
       // object for which DoFs have
       // been allocated at all
-      Assert (dof_offsets[obj_index] != numbers::invalid_unsigned_int,
+      Assert (dof_offsets[obj_index] != numbers::invalid_dof_index,
               ExcMessage ("You are trying to access degree of freedom "
                           "information for an object on which no such "
                           "information is available"));
@@ -529,7 +529,7 @@ namespace internal
           unsigned int counter = 0;
           while (true)
             {
-              Assert (*pointer != numbers::invalid_unsigned_int,
+              Assert (*pointer != numbers::invalid_dof_index,
                       ExcInternalError());
 
               const unsigned int fe_index = *pointer;
@@ -575,7 +575,7 @@ namespace internal
       // make sure we are on an
       // object for which DoFs have
       // been allocated at all
-      Assert (dof_offsets[obj_index] != numbers::invalid_unsigned_int,
+      Assert (dof_offsets[obj_index] != numbers::invalid_dof_index,
               ExcMessage ("You are trying to access degree of freedom "
                           "information for an object on which no such "
                           "information is available"));
@@ -610,7 +610,7 @@ namespace internal
           const types::global_dof_index  *pointer = &dofs[starting_offset];
           while (true)
             {
-              if (*pointer == numbers::invalid_unsigned_int)
+              if (*pointer == numbers::invalid_dof_index)
                 // end of list reached
                 return false;
               else if (*pointer == fe_index)
index c1ff69c2e20008ee9bd8be9be79d3e0642905d9a..b2fdf6919b3dd620d258d1c555b1629827d92147 100644 (file)
@@ -1677,7 +1677,7 @@ namespace internal
           current_block       = parent.n_blocks();
           index_within_block  = 0;
           next_break_backward = global_index;
-          next_break_forward  = numbers::invalid_unsigned_int;
+          next_break_forward  = numbers::invalid_size_type;
         };
     }
 
@@ -1709,7 +1709,7 @@ namespace internal
             // then move the next
             // boundary arbitrarily far
             // away
-            next_break_forward = numbers::invalid_unsigned_int;
+            next_break_forward = numbers::invalid_size_type;
         };
 
       ++global_index;
@@ -1743,7 +1743,7 @@ namespace internal
         // get into unspecified terrain
         {
           --current_block;
-          index_within_block = numbers::invalid_unsigned_int;
+          index_within_block = numbers::invalid_size_type;
           next_break_forward = 0;
           next_break_backward = 0;
         };
index c4df71fa0e250e91803e098ae4a9e2dcc3390642..cbd11d0ce640eb6c5112f95c372f34e22fdaaced 100644 (file)
@@ -1610,11 +1610,11 @@ private:
    * contains the position of the
    * ConstraintLine of a constrained degree
    * of freedom, or
-   * numbers::invalid_unsigned_int if the
+   * numbers::invalid_size_type if the
    * degree of freedom is not
    * constrained. The
-   * numbers::invalid_unsigned_int
-  * return value returns thus whether
+   * numbers::invalid_size_type
+   * return value returns thus whether
    * there is a constraint line for a given
    * degree of freedom index. Note that
    * this class has no notion of how many
@@ -1841,7 +1841,7 @@ ConstraintMatrix::add_line (const size_type line)
   // several terabytes of memory to
   // resize the various arrays below
   // :-)
-  Assert (line != numbers::invalid_unsigned_int,
+  Assert (line != numbers::invalid_size_type,
           ExcInternalError());
   const size_type line_index = calculate_line_index (line);
 
@@ -1885,7 +1885,7 @@ ConstraintMatrix::add_entry (const size_type line,
   // in any case: exit the function if an
   // entry for this column already exists,
   // since we don't want to enter it twice
-  Assert (lines_cache[calculate_line_index(line)] != numbers::invalid_unsigned_int,
+  Assert (lines_cache[calculate_line_index(line)] != numbers::invalid_size_type,
           ExcInternalError());
   ConstraintLine *line_ptr = &lines[lines_cache[calculate_line_index(line)]];
   Assert (line_ptr->line == line, ExcInternalError());
@@ -1911,7 +1911,7 @@ ConstraintMatrix::set_inhomogeneity (const size_type line,
 {
   const size_type line_index = calculate_line_index(line);
   Assert( line_index < lines_cache.size() &&
-          lines_cache[line_index] != numbers::invalid_unsigned_int,
+          lines_cache[line_index] != numbers::invalid_size_type,
           ExcMessage("call add_line() before calling set_inhomogeneity()"));
   Assert(lines_cache[line_index] < lines.size(), ExcInternalError());
   ConstraintLine *line_ptr = &lines[lines_cache[line_index]];
@@ -1950,7 +1950,7 @@ ConstraintMatrix::is_inhomogeneously_constrained (const size_type index) const
   // that means computing the line index twice
   const size_type line_index = calculate_line_index(index);
   if (line_index >= lines_cache.size() ||
-      lines_cache[line_index] == numbers::invalid_unsigned_int)
+      lines_cache[line_index] == numbers::invalid_size_type)
     return false;
   else
     {
@@ -1970,7 +1970,7 @@ ConstraintMatrix::get_constraint_entries (const size_type line) const
   // that means computing the line index twice
   const size_type line_index = calculate_line_index(line);
   if (line_index >= lines_cache.size() ||
-      lines_cache[line_index] == numbers::invalid_unsigned_int)
+      lines_cache[line_index] == numbers::invalid_size_type)
     return 0;
   else
     return &lines[lines_cache[line_index]].entries;
@@ -1987,7 +1987,7 @@ ConstraintMatrix::get_inhomogeneity (const size_type line) const
   // that means computing the line index twice
   const size_type line_index = calculate_line_index(line);
   if (line_index >= lines_cache.size() ||
-      lines_cache[line_index] == numbers::invalid_unsigned_int)
+      lines_cache[line_index] == numbers::invalid_size_type)
     return 0;
   else
     return lines[lines_cache[line_index]].inhomogeneity;
index b039686734ae23259d5ea113e2450ee1a046b1ed..70d3b4f1031804c7bacc024f79647df188a4b8c8 100644 (file)
@@ -707,8 +707,8 @@ template <class MATRIX>
 inline
 MatrixBlock<MATRIX>::MatrixBlock()
   :
-  row(deal_II_numbers::invalid_unsigned_int),
-  column(deal_II_numbers::invalid_unsigned_int)
+  row(deal_II_numbers::invalid_size_type),
+  column(deal_II_numbers::invalid_size_type)
 {}
 
 
index 9f719906a69050759c845045c7e84ec0f9c93622..30cfce14f3e61789be4459d19fd71424baecf005 100644 (file)
@@ -309,7 +309,7 @@ namespace parallel
           Assert (ierr == MPI_SUCCESS, ExcInternalError());
 
           Number *read_position = import_data;
-          std::vector<std::pair<unsigned int, size_type> >::const_iterator
+          std::vector<std::pair<size_type, size_type> >::const_iterator
           my_imports = part.import_indices().begin();
 
           // If add_ghost_data is set, add the imported
@@ -414,7 +414,7 @@ namespace parallel
         {
           Assert (import_data != 0, ExcInternalError());
           Number *write_position = import_data;
-          std::vector<std::pair<unsigned int, size_type> >::const_iterator
+          std::vector<std::pair<size_type, size_type> >::const_iterator
           my_imports = part.import_indices().begin();
           for ( ; my_imports!=part.import_indices().end(); ++my_imports)
             for (size_type j=my_imports->first; j<my_imports->second; j++)
index e4763ef2345a7f7efcec375c738a8bdeb2cf602c..357e44af33164071828581fd0805ef9548ce64e1 100644 (file)
@@ -129,7 +129,7 @@ RelaxationBlock<MATRIX,inverse_type>::invert_diagblocks ()
                 {
                   const size_type column = entry->column();
                   const size_type col_cell = additional_data->block_list.row_position(block, column);
-                  if (col_cell != numbers::invalid_unsigned_int)
+                  if (col_cell != numbers::invalid_size_type)
                     M_cell(row_cell, col_cell) = entry->value();
                 }
             }
index 4080ceafc9f4a26f5d9cb5d36517b6c3fdbc14b8..10d4acb4b37ee5f8906671b3514133e7fd3f17c0 100644 (file)
@@ -79,7 +79,7 @@ void SparseILU<number>::decompose (const SparseMatrix<somenumber> &matrix,
   const size_type N = this->m();
   size_type jrow = 0;
 
-  std::vector<size_type> iw (N, numbers::invalid_unsigned_int);
+  std::vector<size_type> iw (N, numbers::invalid_size_type);
 
   for (size_type k=0; k<N; ++k)
     {
@@ -118,7 +118,7 @@ label_150:
         for (; jj<ia[jrow+1]; ++jj)
           {
             const size_type jw = iw[ja[jj]];
-            if (jw != numbers::invalid_unsigned_int)
+            if (jw != numbers::invalid_size_type)
               luval[jw] -= t1 * luval[jj];
           }
 
@@ -143,7 +143,7 @@ label_200:
       luval[ia[k]] = 1./luval[ia[k]];
 
       for (size_type j=j1; j<=j2; ++j)
-        iw[ja[j]] = numbers::invalid_unsigned_int;
+        iw[ja[j]] = numbers::invalid_size_type;
     }
 }
 
index 1c8f9f8539330b5314f95e5f348438a30b19cf45..96dcad82915e6358534a5dd9df4500bbf245602d 100644 (file)
@@ -497,7 +497,7 @@ namespace internal
       // if we have no constraints, should take the data from dof_indices
       if (row_length_indicators(row) == 0)
         {
-          Assert (row_starts_plain_indices[row] == numbers::invalid_unsigned_int,
+          Assert (row_starts_plain_indices[row] == numbers::invalid_dof_index,
                   ExcInternalError());
           return begin_indices(row);
         }
index 839adb11d3ebcde7ad9131c050ceb8fe9f973822..05e5292e0a60b9423a9207f0f79f6f613ff39e7e 100644 (file)
@@ -2345,7 +2345,7 @@ namespace VectorTools
       VectorDoFTuple ()
       {
         for (unsigned int i=0; i<dim; ++i)
-          dof_indices[i] = numbers::invalid_unsigned_int;
+          dof_indices[i] = numbers::invalid_dof_index;
       }
 
 
index 732bb521beafef3da8e8263faf5506a94b7654b8..01fa8a57363fbeef656d4bdc8670408f39a3f821 100644 (file)
@@ -292,22 +292,22 @@ namespace Utilities
         // space and compress contiguous indices in
         // form of ranges
         {
-          unsigned int last_index = numbers::invalid_unsigned_int-1;
-          std::vector<std::pair<unsigned int,types::global_dof_index> > compressed_import_indices;
+          types::global_dof_index last_index = numbers::invalid_dof_index-1;
+          std::vector<std::pair<types::global_dof_index,types::global_dof_index> > compressed_import_indices;
           for (unsigned int i=0; i<n_import_indices_data; i++)
             {
               Assert (expanded_import_indices[i] >= local_range_data.first &&
                       expanded_import_indices[i] < local_range_data.second,
                       ExcIndexRange(expanded_import_indices[i], local_range_data.first,
                                     local_range_data.second));
-              unsigned int new_index = (expanded_import_indices[i] -
+              types::global_dof_index new_index = (expanded_import_indices[i] -
                                         local_range_data.first);
               if (new_index == last_index+1)
                 compressed_import_indices.back().second++;
               else
                 {
                   compressed_import_indices.push_back
-                  (std::pair<unsigned int,types::global_dof_index>(new_index,new_index+1));
+                  (std::pair<types::global_dof_index,types::global_dof_index>(new_index,new_index+1));
                 }
               last_index = new_index;
             }
index 92aedf95fe29e2108cb8ca591783029b688b1b1d..571286b87f1776b6db031292c0fdc026e1c92789 100644 (file)
@@ -435,7 +435,7 @@ namespace DoFRenumbering
                       const bool                       reversed_numbering,
                       const std::vector<types::global_dof_index> &starting_indices)
   {
-    Assert(dof_handler.n_dofs(level) != numbers::invalid_unsigned_int,
+    Assert(dof_handler.n_dofs(level) != numbers::invalid_dof_index,
            ExcNotInitialized());
 //TODO: we should be doing the same here as in the other compute_CMK function to preserve some memory
 
@@ -497,7 +497,7 @@ namespace DoFRenumbering
     dof_handler.renumber_dofs (renumbering);
 
     // for (unsigned int level=0;level<dof_handler.get_tria().n_levels();++level)
-    //   if (dof_handler.n_dofs(level) != numbers::invalid_unsigned_int)
+    //   if (dof_handler.n_dofs(level) != numbers::invalid_dof_index)
     //  component_wise(dof_handler, level, component_order_arg);
   }
 
@@ -550,7 +550,7 @@ namespace DoFRenumbering
                   const unsigned int level,
                   const std::vector<unsigned int> &component_order_arg)
   {
-    Assert(dof_handler.n_dofs(level) != numbers::invalid_unsigned_int,
+    Assert(dof_handler.n_dofs(level) != numbers::invalid_dof_index,
            ExcNotInitialized());
 
     std::vector<types::global_dof_index> renumbering (dof_handler.n_dofs(level),
@@ -731,8 +731,6 @@ namespace DoFRenumbering
         all_dof_counts(fe_collection.n_components() *
                        Utilities::MPI::n_mpi_processes (tria->get_communicator()));
 
-       Assert (sizeof(types::global_dof_index) == sizeof(unsigned int),
-               ExcNotImplemented());
         MPI_Allgather ( &local_dof_count[0], n_buckets, MPI_UNSIGNED, &all_dof_counts[0],
                         n_buckets, MPI_UNSIGNED, tria->get_communicator());
 
@@ -869,7 +867,7 @@ namespace DoFRenumbering
   void
   block_wise (DoFHandler<dim> &dof_handler, const unsigned int level)
   {
-    Assert(dof_handler.n_dofs(level) != numbers::invalid_unsigned_int,
+    Assert(dof_handler.n_dofs(level) != numbers::invalid_dof_index,
            ExcNotInitialized());
 
     std::vector<types::global_dof_index> renumbering (dof_handler.n_dofs(level),
@@ -1213,7 +1211,7 @@ namespace DoFRenumbering
 
     // make sure that all local DoFs got new numbers assigned
     Assert (std::find (renumbering.begin(), renumbering.end(),
-                       numbers::invalid_unsigned_int)
+                       numbers::invalid_dof_index)
             == renumbering.end(),
             ExcInternalError());
 
@@ -1242,7 +1240,7 @@ namespace DoFRenumbering
                            const std::vector<bool> &selected_dofs,
                            const unsigned int       level)
   {
-    Assert(dof_handler.n_dofs(level) != numbers::invalid_unsigned_int,
+    Assert(dof_handler.n_dofs(level) != numbers::invalid_dof_index,
            ExcNotInitialized());
 
     std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(level),
@@ -1299,7 +1297,7 @@ namespace DoFRenumbering
                                    const std::vector<bool>   &selected_dofs,
                                    const unsigned int         level)
   {
-    Assert(dof_handler.n_dofs(level) != numbers::invalid_unsigned_int,
+    Assert(dof_handler.n_dofs(level) != numbers::invalid_dof_index,
            ExcNotInitialized());
 
     const unsigned int n_dofs = dof_handler.n_dofs(level);
@@ -1422,7 +1420,7 @@ namespace DoFRenumbering
     const unsigned int level,
     const typename std::vector<typename DH::level_cell_iterator> &cells)
   {
-    Assert(dof.n_dofs(level) != numbers::invalid_unsigned_int,
+    Assert(dof.n_dofs(level) != numbers::invalid_dof_index,
            ExcNotInitialized());
 
     std::vector<types::global_dof_index> renumbering(dof.n_dofs(level));
@@ -1885,13 +1883,13 @@ namespace DoFRenumbering
     // same subdomain, then they will be in
     // this order also after reordering
     std::fill (new_dof_indices.begin(), new_dof_indices.end(),
-               numbers::invalid_unsigned_int);
+               numbers::invalid_dof_index);
     types::global_dof_index next_free_index = 0;
     for (types::subdomain_id subdomain=0; subdomain<n_subdomains; ++subdomain)
       for (types::global_dof_index i=0; i<n_dofs; ++i)
         if (subdomain_association[i] == subdomain)
           {
-            Assert (new_dof_indices[i] == numbers::invalid_unsigned_int,
+            Assert (new_dof_indices[i] == numbers::invalid_dof_index,
                     ExcInternalError());
             new_dof_indices[i] = next_free_index;
             ++next_free_index;
@@ -1900,7 +1898,7 @@ namespace DoFRenumbering
     // we should have numbered all dofs
     Assert (next_free_index == n_dofs, ExcInternalError());
     Assert (std::find (new_dof_indices.begin(), new_dof_indices.end(),
-                       numbers::invalid_unsigned_int)
+                       numbers::invalid_dof_index)
             == new_dof_indices.end(),
             ExcInternalError());
   }
index 9a24316886aaf890a1acf4d9f11f853c9d41f8ec..6e3d4ee611961f79a4889302e1930d4281bbeb05 100644 (file)
@@ -1688,10 +1688,10 @@ namespace DoFTools
         // check for a couple conditions that happened in parallel
         // distributed mode
         for (unsigned int row=0; row!=n_slave_dofs; ++row)
-          Assert (slave_dofs[row] != numbers::invalid_unsigned_int,
+          Assert (slave_dofs[row] != numbers::invalid_dof_index,
                   ExcInternalError());
         for (unsigned int col=0; col!=n_master_dofs; ++col)
-          Assert (master_dofs[col] != numbers::invalid_unsigned_int,
+          Assert (master_dofs[col] != numbers::invalid_dof_index,
                   ExcInternalError());
 
 
index 608635a48317e5d952971b63de3df29565743ea6..47e6a3d3572b9ca786abcbcd8b10e501a0aa3c45 100644 (file)
@@ -263,7 +263,7 @@ namespace internal
           // already fill the
           // vertex_dofs_offsets field
           dof_handler.vertex_dofs_offsets.resize (dof_handler.tria->n_vertices(),
-                                                  numbers::invalid_unsigned_int);
+                                                  numbers::invalid_dof_index);
 
           unsigned int vertex_slots_needed = 0;
           for (unsigned int v=0; v<dof_handler.tria->n_vertices(); ++v)
@@ -286,7 +286,7 @@ namespace internal
           for (unsigned int v=0; v<dof_handler.tria->n_vertices(); ++v)
             if (dof_handler.tria->vertex_used(v) == true)
               {
-                unsigned int pointer = dof_handler.vertex_dofs_offsets[v];
+                types::global_dof_index pointer = dof_handler.vertex_dofs_offsets[v];
                 for (unsigned int fe=0; fe<dof_handler.finite_elements->size(); ++fe)
                   if (vertex_fe_association[fe][v] == true)
                     {
@@ -301,7 +301,7 @@ namespace internal
                     }
                 // finally place the end
                 // marker
-                dof_handler.vertex_dofs[pointer] = numbers::invalid_unsigned_int;
+                dof_handler.vertex_dofs[pointer] = numbers::invalid_dof_index;
               }
         }
 
@@ -1421,7 +1421,7 @@ namespace internal
               // line_dofs_offsets field
               dof_handler.faces->lines.dof_offsets
               .resize (dof_handler.tria->n_raw_lines(),
-                       numbers::invalid_unsigned_int);
+                       numbers::invalid_dof_index);
 
               unsigned int line_slots_needed = 0;
               for (unsigned int line=0; line<dof_handler.tria->n_raw_lines(); ++line)
@@ -1459,7 +1459,7 @@ namespace internal
                         }
                     // finally place the end
                     // marker
-                    dof_handler.faces->lines.dofs[pointer] = numbers::invalid_unsigned_int;
+                    dof_handler.faces->lines.dofs[pointer] = numbers::invalid_dof_index;
                   }
             }
 
@@ -2110,7 +2110,7 @@ namespace hp
                                               identities[i].second);
 
                     Assert ((new_dof_indices[higher_dof_index] ==
-                             numbers::invalid_unsigned_int)
+                             numbers::invalid_dof_index)
                             ||
                             (new_dof_indices[higher_dof_index] ==
                              lower_dof_index),
@@ -2281,10 +2281,10 @@ namespace hp
                                   // slave to
                                   // master
                                   if (new_dof_indices[master_dof_index] !=
-                                      numbers::invalid_unsigned_int)
+                                      numbers::invalid_dof_index)
                                     {
                                       Assert (new_dof_indices[new_dof_indices[master_dof_index]] ==
-                                              numbers::invalid_unsigned_int,
+                                              numbers::invalid_dof_index,
                                               ExcInternalError());
 
                                       new_dof_indices[slave_dof_index]
@@ -2293,7 +2293,7 @@ namespace hp
                                   else
                                     {
                                       Assert ((new_dof_indices[master_dof_index] ==
-                                               numbers::invalid_unsigned_int)
+                                               numbers::invalid_dof_index)
                                               ||
                                               (new_dof_indices[slave_dof_index] ==
                                                master_dof_index),
@@ -2359,7 +2359,7 @@ namespace hp
                             = line->dof_index (identities[i].second, other_fe_index);
 
                           Assert ((new_dof_indices[master_dof_index] ==
-                                   numbers::invalid_unsigned_int)
+                                   numbers::invalid_dof_index)
                                   ||
                                   (new_dof_indices[slave_dof_index] ==
                                    master_dof_index),
@@ -2497,7 +2497,7 @@ namespace hp
                         = quad->dof_index (identities[i].second, other_fe_index);
 
                       Assert ((new_dof_indices[master_dof_index] ==
-                               numbers::invalid_unsigned_int)
+                               numbers::invalid_dof_index)
                               ||
                               (new_dof_indices[slave_dof_index] ==
                                master_dof_index),
@@ -2621,7 +2621,7 @@ namespace hp
     // lower-dimensional objects
     // where elements come together
     std::vector<types::global_dof_index>
-    constrained_indices (number_cache.n_global_dofs, numbers::invalid_unsigned_int);
+    constrained_indices (number_cache.n_global_dofs, numbers::invalid_dof_index);
     compute_vertex_dof_identities (constrained_indices);
     compute_line_dof_identities (constrained_indices);
     compute_quad_dof_identities (constrained_indices);
@@ -2630,10 +2630,10 @@ namespace hp
     // new numbers to those which are
     // not constrained
     std::vector<types::global_dof_index>
-    new_dof_indices (number_cache.n_global_dofs, numbers::invalid_unsigned_int);
+    new_dof_indices (number_cache.n_global_dofs, numbers::invalid_dof_index);
     types::global_dof_index next_free_dof = 0;
     for (types::global_dof_index i=0; i<number_cache.n_global_dofs; ++i)
-      if (constrained_indices[i] == numbers::invalid_unsigned_int)
+      if (constrained_indices[i] == numbers::invalid_dof_index)
         {
           new_dof_indices[i] = next_free_dof;
           ++next_free_dof;
@@ -2643,10 +2643,10 @@ namespace hp
     // are constrained and record the
     // new dof number for those:
     for (types::global_dof_index i=0; i<number_cache.n_global_dofs; ++i)
-      if (constrained_indices[i] != numbers::invalid_unsigned_int)
+      if (constrained_indices[i] != numbers::invalid_dof_index)
         {
           Assert (new_dof_indices[constrained_indices[i]] !=
-                  numbers::invalid_unsigned_int,
+                  numbers::invalid_dof_index,
                   ExcInternalError());
 
           new_dof_indices[i] = new_dof_indices[constrained_indices[i]];
@@ -2654,7 +2654,7 @@ namespace hp
 
     for (types::global_dof_index i=0; i<number_cache.n_global_dofs; ++i)
       {
-        Assert (new_dof_indices[i] != numbers::invalid_unsigned_int,
+        Assert (new_dof_indices[i] != numbers::invalid_dof_index,
                 ExcInternalError());
         Assert (new_dof_indices[i] < next_free_dof,
                 ExcInternalError());
@@ -3324,7 +3324,7 @@ namespace hp
                                            const unsigned int) const
   {
     Assert (false, ExcNotImplemented());
-    return numbers::invalid_unsigned_int;
+    return numbers::invalid_dof_index;
   }
 
 
@@ -3356,7 +3356,7 @@ namespace hp
     }
 
     {
-      std::vector<unsigned int> tmp;
+      std::vector<types::global_dof_index> tmp;
       std::swap (vertex_dofs_offsets, tmp);
     }
   }
index 9d80edb4dc8ff5ff37e5935c9f2f51c34ede1fd1..9875a7d1ba0f9a2ebc3c7420f10b524ac40b7ab7 100644 (file)
@@ -941,7 +941,7 @@ SparsityPattern::row_position (const size_type i, const size_type j) const
       // entry exists
       if (colnums[k] == j) return k-rowstart[i];
     }
-  return numbers::invalid_unsigned_int;
+  return numbers::invalid_size_type;
 }
 
 
index 6e1103f7f0877d33109d057e7efbb4a9a0d1e249..a11b444c70b18d6ea30f97dc8937c7cb3bdafd0a 100644 (file)
@@ -139,7 +139,7 @@ namespace SparsityTools
   {
     /**
      * Given a connectivity graph and a list of indices (where
-     * invalid_unsigned_int indicates that a node has not been numbered yet),
+     * invalid_size_type indicates that a node has not been numbered yet),
      * pick a valid starting index among the as-yet unnumbered one.
      */
     size_type 
@@ -147,11 +147,11 @@ namespace SparsityTools
                                     const std::vector<size_type> &new_indices)
     {
       {
-        size_type starting_point   = numbers::invalid_unsigned_int;
+        size_type starting_point   = numbers::invalid_size_type;
         size_type min_coordination = sparsity.n_rows();
         for (size_type row=0; row<sparsity.n_rows(); ++row)
           // look over all as-yet unnumbered indices
-          if (new_indices[row] == numbers::invalid_unsigned_int)
+          if (new_indices[row] == numbers::invalid_size_type)
             {
               SparsityPattern::iterator j = sparsity.begin(row);
 
@@ -176,16 +176,16 @@ namespace SparsityTools
         //
         // if that should be the case, we can chose an arbitrary dof as
         // starting point, e.g. the first unnumbered one
-        if (starting_point == numbers::invalid_unsigned_int)
+        if (starting_point == numbers::invalid_size_type)
           {
             for (size_type i=0; i<new_indices.size(); ++i)
-              if (new_indices[i] == numbers::invalid_unsigned_int)
+              if (new_indices[i] == numbers::invalid_size_type)
                 {
                   starting_point = i;
                   break;
                 }
 
-            Assert (starting_point != numbers::invalid_unsigned_int,
+            Assert (starting_point != numbers::invalid_size_type,
                     ExcInternalError());
           }
 
@@ -216,17 +216,17 @@ namespace SparsityTools
 
     // initialize the new_indices array with invalid values
     std::fill (new_indices.begin(), new_indices.end(),
-               numbers::invalid_unsigned_int);
+               numbers::invalid_size_type);
 
     // delete disallowed elements
     for (size_type i=0; i<last_round_dofs.size(); ++i)
-      if ((last_round_dofs[i]==numbers::invalid_unsigned_int) ||
+      if ((last_round_dofs[i]==numbers::invalid_size_type) ||
           (last_round_dofs[i]>=sparsity.n_rows()))
-        last_round_dofs[i] = numbers::invalid_unsigned_int;
+        last_round_dofs[i] = numbers::invalid_size_type;
 
     std::remove_if (last_round_dofs.begin(), last_round_dofs.end(),
                     std::bind2nd(std::equal_to<size_type>(),
-                                 numbers::invalid_unsigned_int));
+                                 numbers::invalid_size_type));
 
     // now if no valid points remain: find dof with lowest coordination number
     if (last_round_dofs.empty())
@@ -271,7 +271,7 @@ namespace SparsityTools
         // eliminate dofs which are
         // already numbered
         for (int s=next_round_dofs.size()-1; s>=0; --s)
-          if (new_indices[next_round_dofs[s]] != numbers::invalid_unsigned_int)
+          if (new_indices[next_round_dofs[s]] != numbers::invalid_size_type)
             next_round_dofs.erase (next_round_dofs.begin() + s);
 
         // check whether there are
@@ -288,7 +288,7 @@ namespace SparsityTools
         if (next_round_dofs.empty())
           {
             if (std::find (new_indices.begin(), new_indices.end(),
-                           numbers::invalid_unsigned_int)
+                           numbers::invalid_size_type)
                 ==
                 new_indices.end())
               // no unnumbered
@@ -366,7 +366,7 @@ namespace SparsityTools
     // front-marching-algorithm (which
     // Cuthill-McKee actually is) has
     // reached all points.
-    Assert ((std::find (new_indices.begin(), new_indices.end(), numbers::invalid_unsigned_int)
+    Assert ((std::find (new_indices.begin(), new_indices.end(), numbers::invalid_size_type)
              ==
              new_indices.end())
             &&
index 3db1882b7ce6733eaa88cc5d3bdf7b7582f7f08c..7a623fcf4d19127662691554d4947eac6fc39e2e 100644 (file)
@@ -487,7 +487,7 @@ void MGTransferBlockSelect<number>::build_matrices (
 
       temp_copy_indices.resize (0);
       temp_copy_indices.resize (sizes[level][selected_block],
-                                numbers::invalid_unsigned_int);
+                                numbers::invalid_dof_index);
 
       // Compute coarse level right hand side
       // by restricting from fine level.
@@ -527,11 +527,11 @@ void MGTransferBlockSelect<number>::build_matrices (
       const types::global_dof_index n_active_dofs =
         std::count_if (temp_copy_indices.begin(), temp_copy_indices.end(),
                        std::bind2nd(std::not_equal_to<types::global_dof_index>(),
-                                    numbers::invalid_unsigned_int));
+                                    numbers::invalid_dof_index));
       copy_indices[selected_block][level].resize (n_active_dofs);
       types::global_dof_index counter = 0;
       for (types::global_dof_index i=0; i<temp_copy_indices.size(); ++i)
-        if (temp_copy_indices[i] != numbers::invalid_unsigned_int)
+        if (temp_copy_indices[i] != numbers::invalid_dof_index)
           copy_indices[selected_block][level][counter++] =
             std::pair<types::global_dof_index, unsigned int> (temp_copy_indices[i], i);
       Assert (counter == n_active_dofs, ExcInternalError());
@@ -577,7 +577,7 @@ void MGTransferBlock<number>::build_matrices (
           {
             temp_copy_indices[block].resize (0);
             temp_copy_indices[block].resize (sizes[level][block],
-                                             numbers::invalid_unsigned_int);
+                                             numbers::invalid_dof_index);
           }
 
       // Compute coarse level right hand side
@@ -607,11 +607,11 @@ void MGTransferBlock<number>::build_matrices (
               std::count_if (temp_copy_indices[block].begin(),
                              temp_copy_indices[block].end(),
                              std::bind2nd(std::not_equal_to<types::global_dof_index>(),
-                                          numbers::invalid_unsigned_int));
+                                          numbers::invalid_dof_index));
             copy_indices[block][level].resize (n_active_dofs);
             types::global_dof_index counter = 0;
             for (types::global_dof_index i=0; i<temp_copy_indices[block].size(); ++i)
-              if (temp_copy_indices[block][i] != numbers::invalid_unsigned_int)
+              if (temp_copy_indices[block][i] != numbers::invalid_dof_index)
                 copy_indices[block][level][counter++] =
                   std::pair<types::global_dof_index, unsigned int>
                   (temp_copy_indices[block][i], i);
index c0eab8366597daaaf655c635452e538fa08c1e34..8d920f126eb8a009702319a7cc47b5e4f5a0b22d 100644 (file)
@@ -629,7 +629,7 @@ void MGTransferSelect<number>::build_matrices (
       level_end  = mg_dof.end_active(level);
 
       temp_copy_indices.resize (0);
-      temp_copy_indices.resize (mg_dof.n_dofs(level), numbers::invalid_unsigned_int);
+      temp_copy_indices.resize (mg_dof.n_dofs(level), numbers::invalid_dof_index);
 
       // Compute coarse level right hand side
       // by restricting from fine level.
@@ -664,11 +664,11 @@ void MGTransferSelect<number>::build_matrices (
       const types::global_dof_index n_active_dofs =
         std::count_if (temp_copy_indices.begin(), temp_copy_indices.end(),
                        std::bind2nd(std::not_equal_to<types::global_dof_index>(),
-                                    numbers::invalid_unsigned_int));
+                                    numbers::invalid_dof_index));
       copy_to_and_from_indices[level].resize (n_active_dofs);
       types::global_dof_index counter = 0;
       for (types::global_dof_index i=0; i<temp_copy_indices.size(); ++i)
-        if (temp_copy_indices[i] != numbers::invalid_unsigned_int)
+        if (temp_copy_indices[i] != numbers::invalid_dof_index)
           copy_to_and_from_indices[level][counter++] =
             std::pair<types::global_dof_index, unsigned int> (temp_copy_indices[i], i);
       Assert (counter == n_active_dofs, ExcInternalError());
index f8f482e136be9684c835fc4479c8a64aadd7cb25..4c7031eac3e932b52fb2d6d97e6ba895defcd3d6 100644 (file)
@@ -277,7 +277,7 @@ void MGTransferPrebuilt<VECTOR>::build_matrices (
       level_end  = mg_dof.end_active(level);
 
       temp_copy_indices.resize (0);
-      temp_copy_indices.resize (mg_dof.n_dofs(level), numbers::invalid_unsigned_int);
+      temp_copy_indices.resize (mg_dof.n_dofs(level), numbers::invalid_dof_index);
 
       // Compute coarse level right hand side
       // by restricting from fine level.
@@ -311,11 +311,11 @@ void MGTransferPrebuilt<VECTOR>::build_matrices (
       const types::global_dof_index n_active_dofs =
         std::count_if (temp_copy_indices.begin(), temp_copy_indices.end(),
                        std::bind2nd(std::not_equal_to<types::global_dof_index>(),
-                                    numbers::invalid_unsigned_int));
+                                    numbers::invalid_dof_index));
       copy_indices[level].resize (n_active_dofs);
       types::global_dof_index counter = 0;
       for (types::global_dof_index i=0; i<temp_copy_indices.size(); ++i)
-        if (temp_copy_indices[i] != numbers::invalid_unsigned_int)
+        if (temp_copy_indices[i] != numbers::invalid_dof_index)
           copy_indices[level][counter++] =
             std::pair<types::global_dof_index, unsigned int> (temp_copy_indices[i], i);
       Assert (counter == n_active_dofs, ExcInternalError());
index 2273e230938930a315b78b5244c68d6d1e62a69f..586651a016e5b8ad3a0250a09415bd28d03d511d 100644 (file)
@@ -1062,10 +1062,10 @@ namespace MatrixCreator
               Threads::Mutex::ScopedLock lock (mutex);
               for (unsigned int i=0; i<dofs_per_cell; ++i)
                 {
-                  if (dof_is_on_face[i] && dof_to_boundary_mapping[dofs[i]] != numbers::invalid_unsigned_int)
+                  if (dof_is_on_face[i] && dof_to_boundary_mapping[dofs[i]] != numbers::invalid_dof_index)
                     {
                       for (unsigned int j=0; j<dofs_per_cell; ++j)
-                        if (dof_is_on_face[j] && dof_to_boundary_mapping[dofs[j]] != numbers::invalid_unsigned_int)
+                        if (dof_is_on_face[j] && dof_to_boundary_mapping[dofs[j]] != numbers::invalid_dof_index)
                           {
                             Assert(numbers::is_finite(cell_matrix(i,j)), ExcNumberNotFinite());
                             matrix.add(dof_to_boundary_mapping[dofs[i]],

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.