component_to_unrolled_index
(const TableIndices<rank> &indices)
{
+ (void)indices;
Assert (false, ExcNotImplemented());
return numbers::invalid_unsigned_int;
}
(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());
Number &
operator [] (const unsigned int comp)
{
+ (void)comp;
AssertIndexRange (comp, 1);
return data;
}
const Number &
operator [] (const unsigned int comp) const
{
+ (void)comp;
AssertIndexRange (comp, 1);
return data;
}
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.
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.
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.
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.
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.
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.
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
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
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);
}
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);
}
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);
}
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,
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,
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));
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));
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,
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());
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());
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());
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
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(),
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."));
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>(),
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;
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);
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);
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);
// 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());
}
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()));
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()));
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
matrix(matrix),
base_iterator(matrix->block(0,0).begin())
{
+ (void)col;
Assert(col==0, ExcNotImplemented());
// check if this is a regular row or
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
BlockSparseMatrixEZ<number> &
BlockSparseMatrixEZ<number>::operator = (const double d)
{
+ (void)d;
Assert (d==0, ExcScalarAssignmentOnlyForZeroValue());
for (unsigned int r=0; r<n_block_rows(); ++r)
// 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)
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());
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()));
ChunkSparseMatrix<number> &
ChunkSparseMatrix<number>::operator = (const double d)
{
+ (void)d;
Assert (d==0, ExcScalarAssignmentOnlyForZeroValue());
Assert (cols != 0, ExcNotInitialized());
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(),
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();
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."));
{
// 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."));
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."));
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."));
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."));
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."));
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."));
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."));
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."));
const size_type column,
SparseMatrixIterator &matrix_values)
{
+ (void)row;
if (value != 0.)
{
while (matrix_values->column() < column)
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;
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
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"));
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
}
{
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;
int ierr = MPI_Waitall (n_ghost_targets,
&compress_requests[n_import_targets],
MPI_STATUSES_IGNORE);
+ (void)ierr;
Assert (ierr == MPI_SUCCESS, ExcInternalError());
}
else
{
int ierr = MPI_Startall(update_ghost_values_requests.size(),
&update_ghost_values_requests[0]);
+ (void)ierr;
Assert (ierr == MPI_SUCCESS, ExcInternalError());
}
#else
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
// 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)
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());
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()));
SparseMatrix<number> &
SparseMatrix<number>::operator = (const double d)
{
+ (void)d;
Assert (d==0, ExcScalarAssignmentOnlyForZeroValue());
Assert (cols != 0, ExcNotInitialized());
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(),
(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
"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
}
}
SparseMatrixEZ<number> &
SparseMatrixEZ<number>::operator= (const SparseMatrixEZ<number> &m)
{
+ (void)m;
Assert (m.empty(), ExcInvalidConstructorCall());
return *this;
}
SparseMatrixEZ<number> &
SparseMatrixEZ<number>::operator = (const double d)
{
+ (void)d;
Assert (d==0, ExcScalarAssignmentOnlyForZeroValue());
typename std::vector<Entry>::iterator e = data.begin();
// 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)
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(),
// 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;
static void reinit(Matrix &matrix, Sparsity &sparsity, int level, const DSP &dsp, const DH &)
{
sparsity.copy_from (dsp);
+ (void)level;
matrix.reinit (sparsity);
}
};
{
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()));
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;
}
std::vector<Number> &values,
const unsigned int /*component*/) const
{
+ (void)points;
Assert (values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
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;
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(),
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);