]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Use the (void) trick to silence warnings.
authorDavid Wells <drwells@vt.edu>
Sat, 4 Apr 2015 14:28:45 +0000 (10:28 -0400)
committerMatthias Maier <matthias.maier@iwr.uni-heidelberg.de>
Tue, 14 Apr 2015 10:50:17 +0000 (12:50 +0200)
24 files changed:
include/deal.II/base/symmetric_tensor.h
include/deal.II/base/vectorization.h
include/deal.II/dofs/dof_accessor.templates.h
include/deal.II/dofs/dof_objects.h
include/deal.II/fe/fe.h
include/deal.II/fe/fe_poly.templates.h
include/deal.II/grid/tria_accessor.templates.h
include/deal.II/hp/dof_level.h
include/deal.II/lac/block_matrix_base.h
include/deal.II/lac/block_sparse_matrix_ez.templates.h
include/deal.II/lac/block_vector.h
include/deal.II/lac/chunk_sparse_matrix.templates.h
include/deal.II/lac/constraint_matrix.templates.h
include/deal.II/lac/full_matrix.templates.h
include/deal.II/lac/parallel_vector.templates.h
include/deal.II/lac/petsc_block_vector.h
include/deal.II/lac/sparse_matrix.templates.h
include/deal.II/lac/sparse_matrix_ez.templates.h
include/deal.II/lac/trilinos_block_vector.h
include/deal.II/lac/trilinos_sparse_matrix.h
include/deal.II/lac/vector.templates.h
include/deal.II/multigrid/mg_transfer.h
include/deal.II/numerics/vector_tools.templates.h
source/base/function.cc

index cb6179434e86cc655028726d8fcca09d0e130620..685de47e3807e9641063f9603f058fdd4c1a25cc 100644 (file)
@@ -1937,6 +1937,7 @@ namespace internal
       component_to_unrolled_index
       (const TableIndices<rank> &indices)
       {
+        (void)indices;
         Assert (false, ExcNotImplemented());
         return numbers::invalid_unsigned_int;
       }
@@ -2031,6 +2032,7 @@ namespace internal
       (const unsigned int i,
        const int2type<rank> &)
       {
+        (void)i;
         Assert ((i < dealii::SymmetricTensor<rank,dim,double>::n_independent_components),
                 ExcIndexRange(i, 0, dealii::SymmetricTensor<rank,dim,double>::n_independent_components));
         Assert (false, ExcNotImplemented());
index ae337415bf5ec6be98586c1c943775635fce2e76..81563340e9a49141adb1188dd4a0b2be140b1686 100644 (file)
@@ -1351,6 +1351,7 @@ public:
   Number &
   operator [] (const unsigned int comp)
   {
+    (void)comp;
     AssertIndexRange (comp, 1);
     return data;
   }
@@ -1361,6 +1362,7 @@ public:
   const Number &
   operator [] (const unsigned int comp) const
   {
+    (void)comp;
     AssertIndexRange (comp, 1);
     return data;
   }
index 76f087f2e0ee5a907321da4988ff8d4a4248ba8f..de1d8f4a4ebf8b5bb0c119ac8ec01064fd7ff798 100644 (file)
@@ -248,6 +248,7 @@ namespace internal
                      const unsigned int              local_index,
                      dealii::internal::int2type<1>)
       {
+        (void)obj_level;
         // faces have no levels
         Assert (obj_level == 0, ExcInternalError());
         return dof_handler.faces->lines.
@@ -269,6 +270,7 @@ namespace internal
                      dealii::internal::int2type<1>,
                      const types::global_dof_index              global_index)
       {
+        (void)obj_level;
         // faces have no levels
         Assert (obj_level == 0, ExcInternalError());
         dof_handler.faces->lines.
@@ -328,6 +330,7 @@ namespace internal
                      const unsigned int              local_index,
                      dealii::internal::int2type<1>)
       {
+        (void)obj_level;
         // faces have no levels
         Assert (obj_level == 0, ExcInternalError());
         return dof_handler.faces->lines.
@@ -349,6 +352,7 @@ namespace internal
                      dealii::internal::int2type<1>,
                      const types::global_dof_index              global_index)
       {
+        (void)obj_level;
         // faces have no levels
         Assert (obj_level == 0, ExcInternalError());
         dof_handler.faces->lines.
@@ -371,6 +375,7 @@ namespace internal
                      const unsigned int              local_index,
                      dealii::internal::int2type<2>)
       {
+        (void)obj_level;
         // faces have no levels
         Assert (obj_level == 0, ExcInternalError());
         return dof_handler.faces->quads.
@@ -392,6 +397,7 @@ namespace internal
                      dealii::internal::int2type<2>,
                      const types::global_dof_index              global_index)
       {
+        (void)obj_level;
         // faces have no levels
         Assert (obj_level == 0, ExcInternalError());
         dof_handler.faces->quads.
@@ -692,6 +698,9 @@ namespace internal
                            const unsigned int obj_index,
                            const dealii::internal::int2type<structdim> &)
       {
+        (void)dof_handler;
+        (void)obj_level;
+        (void)obj_index;
         // check that the object we look
         // at is in fact active. the
         // problem is that we have
@@ -740,6 +749,10 @@ namespace internal
                            const unsigned int n,
                            const dealii::internal::int2type<structdim> &)
       {
+        (void)dof_handler;
+        (void)obj_level;
+        (void)obj_index;
+        (void)n;
         // check that the object we look
         // at is in fact active. the
         // problem is that we have
@@ -817,6 +830,7 @@ namespace internal
                            const unsigned int n,
                            const dealii::internal::int2type<1> &)
       {
+        (void)n;
         Assert (n==0, ExcMessage("On cells, there can only be one active FE index"));
         return dof_handler.levels[obj_level]->active_fe_index (obj_index);
       }
@@ -905,6 +919,7 @@ namespace internal
                            const unsigned int n,
                            const dealii::internal::int2type<2> &)
       {
+        (void)n;
         Assert (n==0, ExcMessage("On cells, there can only be one active FE index"));
         return dof_handler.levels[obj_level]->active_fe_index (obj_index);
       }
@@ -1041,6 +1056,7 @@ namespace internal
                            const unsigned int n,
                            const dealii::internal::int2type<3> &)
       {
+        (void)n;
         Assert (n==0, ExcMessage("On cells, there can only be one active FE index"));
         return dof_handler.levels[obj_level]->active_fe_index (obj_index);
       }
@@ -1059,6 +1075,7 @@ namespace internal
                             const unsigned int local_index,
                             const types::global_dof_index global_index)
       {
+        (void)fe_index;
         Assert ((fe_index == dealii::DoFHandler<dim,spacedim>::default_fe_index),
                 ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
         Assert (dof_handler.selected_fe != 0,
@@ -1147,6 +1164,7 @@ namespace internal
                             const unsigned int fe_index,
                             const unsigned int local_index)
       {
+        (void)fe_index;
         Assert ((fe_index == dealii::DoFHandler<dim,spacedim>::default_fe_index),
                 ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
         Assert (dof_handler.selected_fe != 0,
@@ -1548,6 +1566,7 @@ DoFAccessor<structdim, DH,level_dof_access>::mg_vertex_dof_index (const int leve
     const unsigned int i,
     const unsigned int fe_index) const
 {
+  (void)fe_index;
   Assert (this->dof_handler != 0, ExcInvalidObject ());
   Assert (vertex < GeometryInfo<structdim>::vertices_per_cell, ExcIndexRange (vertex, 0, GeometryInfo<structdim>::vertices_per_cell));
   Assert (i < this->dof_handler->get_fe ()[fe_index].dofs_per_vertex, ExcIndexRange (i, 0, this->dof_handler->get_fe ()[fe_index].dofs_per_vertex));
@@ -1581,6 +1600,7 @@ DoFAccessor<structdim, DH,level_dof_access>::set_mg_vertex_dof_index (const int
     const types::global_dof_index index,
     const unsigned int fe_index) const
 {
+  (void)fe_index;
   Assert (this->dof_handler != 0, ExcInvalidObject ());
   Assert (vertex < GeometryInfo<structdim>::vertices_per_cell, ExcIndexRange (vertex, 0, GeometryInfo<structdim>::vertices_per_cell));
   Assert (i < this->dof_handler->get_fe ()[fe_index].dofs_per_vertex, ExcIndexRange (i, 0, this->dof_handler->get_fe ()[fe_index].dofs_per_vertex));
@@ -2245,6 +2265,7 @@ vertex_dof_index (const unsigned int vertex,
                   const unsigned int i,
                   const unsigned int fe_index) const
 {
+  (void)vertex;
   Assert (vertex == 0, ExcIndexRange (vertex, 0, 1));
   return dealii::internal::DoFAccessor::Implementation::get_vertex_dof_index (
            *dof_handler,
@@ -2564,6 +2585,7 @@ namespace internal
         const unsigned int dofs_per_vertex = accessor.get_fe().dofs_per_vertex,
                            dofs_per_line   = accessor.get_fe().dofs_per_line,
                            dofs_per_cell   = accessor.get_fe().dofs_per_cell;
+        (void)dofs_per_cell;
 
         Assert (local_dof_indices.size() == dofs_per_cell,
                 ExcInternalError());
@@ -2597,6 +2619,7 @@ namespace internal
                            dofs_per_line   = accessor.get_fe().dofs_per_line,
                            dofs_per_quad   = accessor.get_fe().dofs_per_quad,
                            dofs_per_cell   = accessor.get_fe().dofs_per_cell;
+        (void)dofs_per_cell;
 
         Assert (local_dof_indices.size() == dofs_per_cell,
                 ExcInternalError());
@@ -2634,6 +2657,7 @@ namespace internal
                            dofs_per_quad   = accessor.get_fe().dofs_per_quad,
                            dofs_per_hex    = accessor.get_fe().dofs_per_hex,
                            dofs_per_cell   = accessor.get_fe().dofs_per_cell;
+        (void)dofs_per_cell;
 
         Assert (local_dof_indices.size() == dofs_per_cell,
                 ExcInternalError());
@@ -2746,6 +2770,7 @@ namespace internal
       set_active_fe_index (const DoFCellAccessor<DoFHandler<dim,spacedim>, level_dof_access> &,
                            const unsigned int                                i)
       {
+        (void)i;
         // ::DoFHandler only supports a
         // single active fe with index
         // zero
@@ -3291,6 +3316,7 @@ DoFCellAccessor<DH,level_dof_access>::get_dof_values (const InputVector &values,
                                                       ForwardIterator    local_values_begin,
                                                       ForwardIterator    local_values_end) const
 {
+  (void)local_values_end;
   Assert (this->is_artificial() == false,
           ExcMessage ("Can't ask for DoF indices on artificial cells."));
   Assert (!this->has_children(),
index a7e7690c5070af4d0edad1b6a8168e51af1251d6..e64297f01990b2410ed0b123aef984553a9913d1 100644 (file)
@@ -172,6 +172,7 @@ namespace internal
                                          const types::global_dof_index,
                                          const unsigned int fe_index) const
     {
+      (void)fe_index;
       Assert (fe_index == 0,
               ExcMessage ("Only zero fe_index values are allowed for "
                           "non-hp DoFHandlers."));
@@ -190,6 +191,7 @@ namespace internal
                    const unsigned int       fe_index,
                    const unsigned int       local_index) const
     {
+      (void)fe_index;
       Assert ((fe_index == dealii::DoFHandler<dh_dim,spacedim>::default_fe_index),
               ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
       Assert (local_index<dof_handler.get_fe().template n_dofs_per_object<dim>(),
index f9587adb3120d43168f1de642e5a26479e92535b..1a10880f6ed24ff24529d291103f4b0649bb23e7 100644 (file)
@@ -2096,6 +2096,7 @@ inline
 const FiniteElement<dim,spacedim> &
 FiniteElement<dim,spacedim>::operator[] (const unsigned int fe_index) const
 {
+  (void)fe_index;
   Assert (fe_index == 0,
           ExcMessage ("A fe_index of zero is the only index allowed here"));
   return *this;
index 2f0360c0f21fb465b7e6dd73d7f0fdffdee022a4..d5cf3bf864f66556cf3e6577185e083d2d7ab88a 100644 (file)
@@ -62,6 +62,7 @@ FE_Poly<POLY,dim,spacedim>::shape_value_component (const unsigned int i,
                                                    const Point<dim> &p,
                                                    const unsigned int component) const
 {
+  (void)component;
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   Assert (component == 0, ExcIndexRange (component, 0, 1));
   return poly_space.compute_value(i, p);
@@ -86,6 +87,7 @@ FE_Poly<POLY,dim,spacedim>::shape_grad_component (const unsigned int i,
                                                   const Point<dim> &p,
                                                   const unsigned int component) const
 {
+  (void)component;
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   Assert (component == 0, ExcIndexRange (component, 0, 1));
   return poly_space.compute_grad(i, p);
@@ -110,6 +112,7 @@ FE_Poly<POLY,dim,spacedim>::shape_grad_grad_component (const unsigned int i,
                                                        const Point<dim> &p,
                                                        const unsigned int component) const
 {
+  (void)component;
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   Assert (component == 0, ExcIndexRange (component, 0, 1));
   return poly_space.compute_grad_grad(i, p);
index 1cba57bf1c6ad237243fde41677f963ae5130024..64ebe9f942b5b21b005320900c8081f61328bbd2 100644 (file)
@@ -2139,6 +2139,8 @@ TriaAccessor (const Triangulation<1,spacedim> *tria,
   // of the iterator which calls the accessor with argument list (0,-2,-2,0), so
   // in this particular case accept this call and create an object that corresponds
   // to the default constructed (invalid) vertex accessor
+  (void)level;
+  (void)index;
   Assert ((level == -2) && (index == -2), ExcInternalError());
 }
 
index c4a138ec935aa9791efabf45ccb1413a0d9549e0..c7d6f2ffb1b1314bccbcdaadb41a71945f09859a 100644 (file)
@@ -292,6 +292,7 @@ namespace internal
                    const unsigned int                fe_index,
                    const unsigned int                local_index) const
     {
+      (void)fe_index;
       Assert (obj_index < dof_offsets.size(),
               ExcIndexRange (obj_index, 0, dof_offsets.size()));
 
@@ -324,6 +325,7 @@ namespace internal
                    const unsigned int                local_index,
                    const types::global_dof_index     global_index)
     {
+      (void)fe_index;
       Assert (obj_index < dof_offsets.size(),
               ExcIndexRange (obj_index, 0, dof_offsets.size()));
 
@@ -388,6 +390,7 @@ namespace internal
     DoFLevel::get_cell_cache_start (const unsigned int obj_index,
                                     const unsigned int dofs_per_cell) const
     {
+      (void)dofs_per_cell;
       Assert (obj_index < cell_cache_offsets.size(),
               ExcInternalError());
       Assert (cell_cache_offsets[obj_index]+dofs_per_cell
index 791c97ae2fd7759aec99f563cf9e322af81d9eaf..781a5e1e7877963abff919d49773c3469efceb4b 100644 (file)
@@ -1075,6 +1075,7 @@ namespace BlockMatrixIterators
     matrix(matrix),
     base_iterator(matrix->block(0,0).begin())
   {
+    (void)col;
     Assert(col==0, ExcNotImplemented());
 
     // check if this is a regular row or
@@ -1284,6 +1285,7 @@ namespace BlockMatrixIterators
     matrix(matrix),
     base_iterator(matrix->block(0,0).begin())
   {
+    (void)col;
     Assert(col==0, ExcNotImplemented());
     // check if this is a regular row or
     // the end of the matrix
index 1a0982afe52439575e83986d12a0fb1462f24ac3..3abff0b4dd2de52565bc8f10b590e8cb0dfe91aa 100644 (file)
@@ -76,6 +76,7 @@ template <typename number>
 BlockSparseMatrixEZ<number> &
 BlockSparseMatrixEZ<number>::operator = (const double d)
 {
+  (void)d;
   Assert (d==0, ExcScalarAssignmentOnlyForZeroValue());
 
   for (unsigned int r=0; r<n_block_rows(); ++r)
index 8658febeecf082266d8e74beea3c2c099b4667df..4493d0aa6f3ec5a8d23ceca1c085da7deefad2a0 100644 (file)
@@ -360,6 +360,7 @@ BlockVector<Number>::BlockVector (const std::vector<size_type>    &n,
   // first set sizes of blocks, but
   // don't initialize them as we will
   // copy elements soon
+  (void)end;
   reinit (n, true);
   InputIterator start = first;
   for (size_type b=0; b<n.size(); ++b)
index ca69cc46f58cef10f35691ddac4170f8def055f2..ff49f65b7b1c5d3742c76d06b607a99404843eb7 100644 (file)
@@ -311,6 +311,7 @@ template <typename number>
 ChunkSparseMatrix<number> &
 ChunkSparseMatrix<number>::operator = (const ChunkSparseMatrix<number> &m)
 {
+  (void)m;
   Assert (m.cols==0, ExcInvalidConstructorCall());
   Assert (m.val==0, ExcInvalidConstructorCall());
   Assert (m.max_len==0, ExcInvalidConstructorCall());
@@ -340,6 +341,7 @@ ChunkSparseMatrix<number>::ChunkSparseMatrix (const ChunkSparsityPattern &c,
   val(0),
   max_len(0)
 {
+  (void)id;
   Assert (c.n_rows() == id.m(), ExcDimensionMismatch (c.n_rows(), id.m()));
   Assert (c.n_cols() == id.n(), ExcDimensionMismatch (c.n_cols(), id.n()));
 
@@ -381,6 +383,7 @@ template <typename number>
 ChunkSparseMatrix<number> &
 ChunkSparseMatrix<number>::operator = (const double d)
 {
+  (void)d;
   Assert (d==0, ExcScalarAssignmentOnlyForZeroValue());
 
   Assert (cols != 0, ExcNotInitialized());
@@ -418,6 +421,7 @@ template <typename number>
 ChunkSparseMatrix<number> &
 ChunkSparseMatrix<number>::operator= (const IdentityMatrix  &id)
 {
+  (void)id;
   Assert (cols->n_rows() == id.m(),
           ExcDimensionMismatch (cols->n_rows(), id.m()));
   Assert (cols->n_cols() == id.n(),
@@ -601,6 +605,7 @@ ChunkSparseMatrix<number>::extract_row_copy (const size_type row,
                                              size_type *column_indices,
                                              number *values) const
 {
+  (void)array_length;
   AssertIndexRange(cols->row_length(row), array_length+1);
   AssertIndexRange(row, m());
   const unsigned int chunk_size = cols->get_chunk_size();
@@ -1238,6 +1243,8 @@ ChunkSparseMatrix<number>::precondition_Jacobi (Vector<somenumber>       &dst,
                                                 const Vector<somenumber> &src,
                                                 const number              /*om*/) const
 {
+  (void)dst;
+  (void)src;
   Assert (cols != 0, ExcNotInitialized());
   Assert (val != 0, ExcNotInitialized());
   Assert (m() == n(), ExcMessage("This operation is only valid on square matrices."));
@@ -1259,6 +1266,8 @@ ChunkSparseMatrix<number>::precondition_SSOR (Vector<somenumber>       &dst,
 {
   // to understand how this function works you may want to take a look at the
   // CVS archives to see the original version which is much clearer...
+  (void)dst;
+  (void)src;
   Assert (cols != 0, ExcNotInitialized());
   Assert (val != 0, ExcNotInitialized());
   Assert (m() == n(), ExcMessage("This operation is only valid on square matrices."));
@@ -1310,6 +1319,7 @@ void
 ChunkSparseMatrix<number>::SOR (Vector<somenumber> &dst,
                                 const number /*om*/) const
 {
+  (void)dst;
   Assert (cols != 0, ExcNotInitialized());
   Assert (val != 0, ExcNotInitialized());
   Assert (m() == n(), ExcMessage("This operation is only valid on square matrices."));
@@ -1325,6 +1335,7 @@ void
 ChunkSparseMatrix<number>::TSOR (Vector<somenumber> &dst,
                                  const number /*om*/) const
 {
+  (void)dst;
   Assert (cols != 0, ExcNotInitialized());
   Assert (val != 0, ExcNotInitialized());
   Assert (m() == n(), ExcMessage("This operation is only valid on square matrices."));
@@ -1342,6 +1353,9 @@ ChunkSparseMatrix<number>::PSOR (Vector<somenumber> &dst,
                                  const std::vector<size_type> &inverse_permutation,
                                  const number /*om*/) const
 {
+  (void)dst;
+  (void)permutation;
+  (void)inverse_permutation;
   Assert (cols != 0, ExcNotInitialized());
   Assert (val != 0, ExcNotInitialized());
   Assert (m() == n(), ExcMessage("This operation is only valid on square matrices."));
@@ -1364,6 +1378,9 @@ ChunkSparseMatrix<number>::TPSOR (Vector<somenumber> &dst,
                                   const std::vector<size_type> &inverse_permutation,
                                   const number /*om*/) const
 {
+  (void)dst;
+  (void)permutation;
+  (void)inverse_permutation;
   Assert (cols != 0, ExcNotInitialized());
   Assert (val != 0, ExcNotInitialized());
   Assert (m() == n(), ExcMessage("This operation is only valid on square matrices."));
@@ -1386,6 +1403,8 @@ ChunkSparseMatrix<number>::SOR_step (Vector<somenumber> &v,
                                      const Vector<somenumber> &b,
                                      const number        /*om*/) const
 {
+  (void)v;
+  (void)b;
   Assert (cols != 0, ExcNotInitialized());
   Assert (val != 0, ExcNotInitialized());
   Assert (m() == n(), ExcMessage("This operation is only valid on square matrices."));
@@ -1405,6 +1424,8 @@ ChunkSparseMatrix<number>::TSOR_step (Vector<somenumber> &v,
                                       const Vector<somenumber> &b,
                                       const number        /*om*/) const
 {
+  (void)v;
+  (void)b;
   Assert (cols != 0, ExcNotInitialized());
   Assert (val != 0, ExcNotInitialized());
   Assert (m() == n(), ExcMessage("This operation is only valid on square matrices."));
@@ -1436,6 +1457,7 @@ void
 ChunkSparseMatrix<number>::SSOR (Vector<somenumber> &dst,
                                  const number /*om*/) const
 {
+  (void)dst;
   Assert (cols != 0, ExcNotInitialized());
   Assert (val != 0, ExcNotInitialized());
   Assert (m() == n(), ExcMessage("This operation is only valid on square matrices."));
index b139753e0a717ded9455ba63fbbfed18240cee8f..2fe7edc31b271da73a790e068b5f855e0a631af4 100644 (file)
@@ -1654,6 +1654,7 @@ namespace internals
                     const size_type       column,
                     SparseMatrixIterator &matrix_values)
     {
+      (void)row;
       if (value != 0.)
         {
           while (matrix_values->column() < column)
@@ -2628,6 +2629,7 @@ add_entries_local_to_global (const std::vector<size_type> &local_dof_indices,
       actual_dof_indices.resize(n_local_dofs);
       make_sorted_row_list (local_dof_indices, actual_dof_indices);
       const size_type n_actual_dofs = actual_dof_indices.size();
+      (void)n_actual_dofs;
 
       // additional construct that also takes care of block indices.
       std::vector<size_type> &block_starts = scratch_data->block_starts;
index 1b7c9c0c3edbe96312fe16ac3a19f7f868814d7e..a03c01200ee3a4e8de7f4aeae2b863966c3e99ba 100644 (file)
@@ -1789,6 +1789,7 @@ FullMatrix<number>::gauss_jordan ()
   for (size_type i=0; i<N; ++i)
     diagonal_sum += std::abs((*this)(i,i));
   const double typical_diagonal_element = diagonal_sum/N;
+  (void)typical_diagonal_element;
 
   // initialize the array that holds
   // the permutations that we find
index 2a7f3d1b739f08bb054aa01ce9bc594fd908c781..eb3495e21fd4d1c0b26230eb9b09070ad1dc2baf 100644 (file)
@@ -308,6 +308,8 @@ namespace parallel
     Vector<Number>::compress_start (const unsigned int counter,
                                     ::dealii::VectorOperation::values operation)
     {
+      (void)counter;
+      (void)operation;
       Assert (vector_is_ghosted == false,
               ExcMessage ("Cannot call compress() on a ghosted vector"));
 
@@ -386,12 +388,9 @@ namespace parallel
       if (compress_requests.size() > 0)
         {
           int ierr = MPI_Startall(compress_requests.size(),&compress_requests[0]);
+          (void)ierr;
           Assert (ierr == MPI_SUCCESS, ExcInternalError());
         }
-
-#else // ifdef DEAL_II_WITH_MPI
-      (void)counter;
-      (void)operation;
 #endif
     }
 
@@ -434,6 +433,7 @@ namespace parallel
         {
           int ierr = MPI_Waitall (n_import_targets, &compress_requests[0],
                                   MPI_STATUSES_IGNORE);
+          (void)ierr;
           Assert (ierr == MPI_SUCCESS, ExcInternalError());
 
           Number *read_position = import_data;
@@ -466,6 +466,7 @@ namespace parallel
           int ierr = MPI_Waitall (n_ghost_targets,
                                   &compress_requests[n_import_targets],
                                   MPI_STATUSES_IGNORE);
+          (void)ierr;
           Assert (ierr == MPI_SUCCESS, ExcInternalError());
         }
       else
@@ -558,6 +559,7 @@ namespace parallel
         {
           int ierr = MPI_Startall(update_ghost_values_requests.size(),
                                   &update_ghost_values_requests[0]);
+          (void)ierr;
           Assert (ierr == MPI_SUCCESS, ExcInternalError());
         }
 #else
@@ -585,6 +587,7 @@ namespace parallel
           int ierr = MPI_Waitall (update_ghost_values_requests.size(),
                                   &update_ghost_values_requests[0],
                                   MPI_STATUSES_IGNORE);
+          (void)ierr;
           Assert (ierr == MPI_SUCCESS, ExcInternalError());
         }
 #endif
index c443584382e37afb6345f8ba9f5ea76248720013..2fc9a57f97fe0bcd1229f20449a21ee13f588218 100644 (file)
@@ -302,6 +302,7 @@ namespace PETScWrappers
     // first set sizes of blocks, but
     // don't initialize them as we will
     // copy elements soon
+    (void)end;
     reinit (n, true);
     InputIterator start = first;
     for (unsigned int b=0; b<n.size(); ++b)
index 05264fb950dffba78fe3c7285eeea7bbe17411f5..c013e05c8b7e49b0bb7ab2d7be02ac497de7471b 100644 (file)
@@ -73,6 +73,7 @@ template <typename number>
 SparseMatrix<number> &
 SparseMatrix<number>::operator = (const SparseMatrix<number> &m)
 {
+  (void)m;
   Assert (m.cols==0, ExcInvalidConstructorCall());
   Assert (m.val==0, ExcInvalidConstructorCall());
   Assert (m.max_len==0, ExcInvalidConstructorCall());
@@ -102,6 +103,7 @@ SparseMatrix<number>::SparseMatrix (const SparsityPattern &c,
   val(0),
   max_len(0)
 {
+  (void)id;
   Assert (c.n_rows() == id.m(), ExcDimensionMismatch (c.n_rows(), id.m()));
   Assert (c.n_cols() == id.n(), ExcDimensionMismatch (c.n_cols(), id.n()));
 
@@ -145,6 +147,7 @@ template <typename number>
 SparseMatrix<number> &
 SparseMatrix<number>::operator = (const double d)
 {
+  (void)d;
   Assert (d==0, ExcScalarAssignmentOnlyForZeroValue());
 
   Assert (cols != 0, ExcNotInitialized());
@@ -180,6 +183,7 @@ template <typename number>
 SparseMatrix<number> &
 SparseMatrix<number>::operator= (const IdentityMatrix  &id)
 {
+  (void)id;
   Assert (cols->n_rows() == id.m(),
           ExcDimensionMismatch (cols->n_rows(), id.m()));
   Assert (cols->n_cols() == id.n(),
@@ -384,6 +388,7 @@ SparseMatrix<number>::copy_from (const TrilinosWrappers::SparseMatrix &matrix)
           (row, matrix.row_length(row), ncols,
            &(value_cache[0]),
            reinterpret_cast<TrilinosWrappers::types::int_type *>(&(colnum_cache[0])));
+      (void)ierr;
       Assert (ierr==0, ExcTrilinosError(ierr));
 
       // resize arrays to the size actually used
@@ -1338,6 +1343,8 @@ namespace
                         "preconditioner. If it is correct that there are "
                         "zeros on the diagonal, then you will have to chose "
                         "a different preconditioner."));
+#else
+    (void)matrix;
 #endif
   }
 }
index 4fe449fc5d6a72baa2ea01853caf8c99a5099e30..9580e77c54094848320f6ea0d68d2f30712309b1 100644 (file)
@@ -66,6 +66,7 @@ template <typename number>
 SparseMatrixEZ<number> &
 SparseMatrixEZ<number>::operator= (const SparseMatrixEZ<number> &m)
 {
+  (void)m;
   Assert (m.empty(), ExcInvalidConstructorCall());
   return *this;
 }
@@ -75,6 +76,7 @@ template <typename number>
 SparseMatrixEZ<number> &
 SparseMatrixEZ<number>::operator = (const double d)
 {
+  (void)d;
   Assert (d==0, ExcScalarAssignmentOnlyForZeroValue());
 
   typename std::vector<Entry>::iterator e = data.begin();
index bdfd91e8829ae96688cb524cd8b4d36b7099078c..422c54817ebafa8892f4973f1910335259b12b17 100644 (file)
@@ -348,6 +348,7 @@ namespace TrilinosWrappers
     // first set sizes of blocks, but
     // don't initialize them as we will
     // copy elements soon
+    (void)end;
     reinit (n, true);
     InputIterator start = first;
     for (size_type b=0; b<n.size(); ++b)
index fe1d1cba64ae3f2b8aecd991b0afd51695582c46..938f83cb45e2f824e48a2534b0d755c55a7037c2 100644 (file)
@@ -3111,8 +3111,10 @@ namespace TrilinosWrappers
 
     internal::SparseMatrix::check_vector_map_equality(*matrix, dst, src);
     const size_type dst_local_size = dst.end() - dst.begin();
+    (void)dst_local_size;
     AssertDimension (dst_local_size, static_cast<size_type>(matrix->DomainMap().NumMyElements()));
     const size_type src_local_size = src.end() - src.begin();
+    (void)src_local_size;
     AssertDimension (src_local_size, static_cast<size_type>(matrix->RangeMap().NumMyElements()));
 
     Epetra_MultiVector tril_dst (View, matrix->DomainMap(), dst.begin(),
index 9aa6f0d26160cc36e9dd6c9bdd69f20b72426f7a..2d46fd10dd7b76f9b189c650e4505f6d149be0c6 100644 (file)
@@ -1192,6 +1192,7 @@ namespace internal
           // work on the regular part. The innermost 32 values are expanded in
           // order to obtain known loop bounds for most of the work.
           const Number *X_original = X;
+          (void)X_original;
           ResultType outer_results [128];
           size_type n_chunks = vec_size / 32;
           const size_type remainder = vec_size % 32;
index 8d8adb3e0ab5721319eb8923646bbe91a1ab9458..d6d5ae5bcf0c5a94ee67fead6f48d0d92842ca00 100644 (file)
@@ -52,6 +52,7 @@ namespace internal
     static void reinit(Matrix &matrix, Sparsity &sparsity, int level, const DSP &dsp, const DH &)
     {
       sparsity.copy_from (dsp);
+      (void)level;
       matrix.reinit (sparsity);
     }
   };
index 93fc02cc9e1f6e7dd68b72e50c0d7e0246d8564f..0a41091f162489bd90563b8f10ccea90ee563333 100644 (file)
@@ -598,6 +598,7 @@ namespace VectorTools
   {
     const DH<dim, spacedim> &dof1 = intergridmap.get_source_grid();
     const DH<dim, spacedim> &dof2 = intergridmap.get_destination_grid();
+    (void)dof2;
 
     Assert(u1.size()==dof1.n_dofs(),
            ExcDimensionMismatch(u1.size(), dof1.n_dofs()));
index 826f1bc8a92f61a370c04cf7bc1e7ffb23634e61..91950f7dcca3ca7b37cd707eb7a380c658a5d550 100644 (file)
@@ -53,6 +53,7 @@ Function<dim, Number>::~Function ()
 template <int dim, typename Number>
 Function<dim, Number> &Function<dim, Number>::operator= (const Function &f)
 {
+  (void)f;
   AssertDimension (n_components, f.n_components);
   return *this;
 }
@@ -280,6 +281,7 @@ void ZeroFunction<dim, Number>::value_list (const std::vector<Point<dim> > &poin
                                             std::vector<Number>            &values,
                                             const unsigned int         /*component*/) const
 {
+  (void)points;
   Assert (values.size() == points.size(),
           ExcDimensionMismatch(values.size(), points.size()));
 
@@ -373,6 +375,7 @@ template <int dim, typename Number>
 Number ConstantFunction<dim, Number>::value (const Point<dim> &,
                                              const unsigned int component) const
 {
+  (void)component;
   Assert (component < this->n_components,
           ExcIndexRange (component, 0, this->n_components));
   return function_value;
@@ -397,6 +400,8 @@ void ConstantFunction<dim, Number>::value_list (const std::vector<Point<dim> > &
                                                 std::vector<Number>            &values,
                                                 const unsigned int              component) const
 {
+  (void)points;
+  (void)component;
   Assert (component < this->n_components,
           ExcIndexRange (component, 0, this->n_components));
   Assert (values.size() == points.size(),
@@ -533,6 +538,7 @@ Number
 ScalarFunctionFromFunctionObject<dim, Number>::value (const Point<dim> &p,
                                                       const unsigned int component) const
 {
+  (void)component;
   Assert (component == 0,
           ExcMessage ("This object represents only scalar functions"));
   return function_object (p);

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.