&process_answer,
const MPI_Comm comm)
{
- (void)comm;
Assert(Utilities::MPI::n_mpi_processes(comm) == 1,
ExcMessage("You shouldn't use the 'Serial' class on "
"communicators that have more than one process "
inline void
Tensor<0, dim, Number>::unroll(const Iterator begin, const Iterator end) const
{
- (void)end;
AssertDimension(std::distance(begin, end), n_independent_components);
Assert(dim != 0,
ExcMessage("Cannot unroll an object of type Tensor<0,0,Number>"));
Tensor<rank_, dim, Number>::operator=(const Number &d) &
{
Assert(numbers::value_is_zero(d), ExcScalarAssignmentOnlyForZeroValue());
- (void)d;
for (unsigned int i = 0; i < dim; ++i)
values[i] = internal::NumberType<Number>::value(0.0);
{
// For rank-1 tensors, we can simply copy the current elements from
// our linear array into the output range:
- (void)end;
Assert(std::distance(begin, end) >= dim,
ExcMessage(
"The provided iterator range must contain at least 'dim' "
// Work-around nvcc warning
unsigned int dummy = n_independent_components;
AssertIndexRange(i, dummy);
- (void)dummy;
if constexpr (dim == 0)
{
const MergeConflictBehavior merge_conflict_behavior,
const bool allow_different_local_lines)
{
- (void)allow_different_local_lines;
Assert(allow_different_local_lines ||
local_lines == other_constraints.local_lines,
ExcMessage(
size_type shift = 0)
{
Assert(shift == 0, ExcNotImplemented());
- (void)shift;
std::vector<size_type> constrained_local_dofs_host;
constrained_local_dofs_host.reserve(cm.size());
const size_type column,
SparseMatrixIterator &matrix_values)
{
- (void)row;
if (value != LocalType())
{
while (matrix_values->column() < column)
: 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
// first set sizes of blocks, but
// don't initialize them as we will
// copy elements soon
- (void)end;
reinit(block_sizes, true);
InputIterator start = first;
for (size_type b = 0; b < block_sizes.size(); ++b)
ChunkSparseMatrix<number> &
ChunkSparseMatrix<number>::operator=(const ChunkSparseMatrix<number> &m)
{
- (void)m;
Assert(m.cols == nullptr && m.val == nullptr && m.max_len == 0,
ExcMessage(
"This operator can only be called if the provided right "
, val(nullptr)
, 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 != nullptr, ExcNeedsSparsityPattern());
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 != nullptr, ExcNeedsSparsityPattern());
Assert(val != nullptr, ExcNotInitialized());
Assert(m() == n(),
{
// 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 != nullptr, ExcNeedsSparsityPattern());
Assert(val != nullptr, ExcNotInitialized());
Assert(m() == n(),
ChunkSparseMatrix<number>::SOR(Vector<somenumber> &dst,
const number /*om*/) const
{
- (void)dst;
Assert(cols != nullptr, ExcNeedsSparsityPattern());
Assert(val != nullptr, ExcNotInitialized());
Assert(m() == n(),
ChunkSparseMatrix<number>::TSOR(Vector<somenumber> &dst,
const number /*om*/) const
{
- (void)dst;
Assert(cols != nullptr, ExcNeedsSparsityPattern());
Assert(val != nullptr, ExcNotInitialized());
Assert(m() == n(),
const std::vector<size_type> &inverse_permutation,
const number /*om*/) const
{
- (void)dst;
- (void)permutation;
- (void)inverse_permutation;
Assert(cols != nullptr, ExcNeedsSparsityPattern());
Assert(val != nullptr, ExcNotInitialized());
Assert(m() == n(),
const std::vector<size_type> &inverse_permutation,
const number /*om*/) const
{
- (void)dst;
- (void)permutation;
- (void)inverse_permutation;
Assert(cols != nullptr, ExcNeedsSparsityPattern());
Assert(val != nullptr, ExcNotInitialized());
Assert(m() == n(),
const Vector<somenumber> &b,
const number /*om*/) const
{
- (void)v;
- (void)b;
Assert(cols != nullptr, ExcNeedsSparsityPattern());
Assert(val != nullptr, ExcNotInitialized());
Assert(m() == n(),
const Vector<somenumber> &b,
const number /*om*/) const
{
- (void)v;
- (void)b;
Assert(cols != nullptr, ExcNeedsSparsityPattern());
Assert(val != nullptr, ExcNotInitialized());
Assert(m() == n(),
ChunkSparseMatrix<number>::SSOR(Vector<somenumber> &dst,
const number /*om*/) const
{
- (void)dst;
Assert(cols != nullptr, ExcNeedsSparsityPattern());
Assert(val != nullptr, ExcNotInitialized());
Assert(m() == n(),
const size_type j) const
{
Assert(i == j, ExcIndexRange(j, i, i + 1));
- (void)j;
return diagonal(i);
}
DiagonalMatrix<VectorType>::operator()(const size_type i, const size_type j)
{
Assert(i == j, ExcIndexRange(j, i, i + 1));
- (void)j;
return diagonal(i);
}
inline int
Iterator::operator-(const Iterator &other) const
{
- (void)other;
Assert(accessor.sparsity_pattern == other.accessor.sparsity_pattern,
ExcInternalError());
DEAL_II_NOT_IMPLEMENTED();
FullMatrix<number>::operator=(const number d)
{
Assert(d == number(0), ExcScalarAssignmentOnlyForZeroValue());
- (void)d; // removes -Wunused-parameter warning in optimized mode
if (this->n_elements() != 0)
this->reset_values();
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
ExcMessage("The serialized value of size (" + std::to_string(size) +
") does not match the current size (" +
std::to_string(this->size()) + ")"));
- (void)size;
ar &local_range;
Assert(local_range == this->local_range(),
ExcMessage("The serialized value of local_range (" +
") does not match the current local_range (" +
std::to_string(this->local_range().first) + ", " +
std::to_string(this->local_range().second) + ")"));
- (void)local_range;
PetscScalar *array = nullptr;
int ierr = VecGetArray(petsc_vector(), &array);
// for a serial computation (don't!), or nobody implemented, instantiated,
// and tested the parallel version for your vector type.
Assert(other == nullptr, ExcNotImplemented());
- (void)other;
return prev;
}
block(VectorType &vector, const unsigned int b)
{
AssertDimension(b, 0);
- (void)b;
return vector;
}
block(const VectorType &vector, const unsigned int b)
{
AssertDimension(b, 0);
- (void)b;
return vector;
}
block(VectorType &vector, const unsigned int b)
{
AssertDimension(b, 0);
- (void)b;
return vector;
}
SparseMatrix<number> &
SparseMatrix<number>::operator=(const SparseMatrix<number> &m)
{
- (void)m;
Assert(m.cols == nullptr && m.val == nullptr && m.max_len == 0,
ExcMessage("This operator can only be called if the provided right "
"hand side is an empty matrix. This operator can not be "
, val(nullptr)
, 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 != nullptr, ExcNeedsSparsityPattern());
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(),
value_cache.data(),
reinterpret_cast<TrilinosWrappers::types::int_type *>(
colnum_cache.data()));
- (void)ierr;
Assert(ierr == 0, ExcTrilinosError(ierr));
// resize arrays to the size actually used
SparseMatrixEZ<number> &
SparseMatrixEZ<number>::operator=(const SparseMatrixEZ<number> &m)
{
- (void)m;
Assert(m.empty(),
ExcMessage("This operator can only be called if the provided right "
"hand side is an empty matrix. This operator can not be "
SparseMatrixEZ<number> &
SparseMatrixEZ<number>::operator=(const double d)
{
- (void)d;
Assert(d == 0, ExcScalarAssignmentOnlyForZeroValue());
typename std::vector<Entry>::iterator e = data.begin();
std::array<AlignedVector<Number>, dim> &eigenvalues)
{
const unsigned int n_rows_1d = mass_matrix[0].n_cols();
- (void)n_rows_1d;
for (unsigned int dir = 0; dir < dim; ++dir)
{
Assert(dst.Map().SameAs(mtrx.DomainMap()) == true,
ExcMessage("Row map of matrix does not fit with vector map!"));
}
- (void)mtrx; // removes -Wunused-variable in optimized mode
- (void)src;
- (void)dst;
}
inline void
ExcMessage(
"Row map of operator does not fit with vector map!"));
}
- (void)op; // removes -Wunused-variable in optimized mode
- (void)src;
- (void)dst;
}
block_sparsity_pattern.n_block_cols()));
const size_type n_block_rows = tpetra_maps.size();
- (void)n_block_rows;
-
Assert(n_block_rows == block_sparsity_pattern.n_block_rows(),
ExcDimensionMismatch(n_block_rows,
block_sparsity_pattern.n_block_rows()));
SparseMatrix<Number, MemorySpace> &
SparseMatrix<Number, MemorySpace>::operator=(const double d)
{
- (void)d;
Assert(d == 0, ExcScalarAssignmentOnlyForZeroValue());
if (compressed)
Vector<Number, MemorySpace> &
Vector<Number, MemorySpace>::operator=(const Number s)
{
- (void)s;
Assert(s == Number(0.0),
ExcMessage("Only 0 can be assigned to a vector."));
, shared_data(data->shared_data)
, cell_id(data->team_member.league_rank())
{
- (void)dof_index;
AssertIndexRange(dof_index, data->n_dofhandler);
}
VectorizedArrayType &res,
std::bool_constant<true>) const
{
- (void)vec_ptr;
- (void)constant_offset;
- (void)vec;
Assert(vec_ptr == vec.begin() + constant_offset, ExcInternalError());
res.scatter(indices, vec_ptr);
}
// We permit different numbers of matrices, vectors and DoF index vectors.
// So we have to be a bit permissive here.
constexpr int max_index = std::max({n_matrices, n_vectors, n_dof_indices});
- (void)max_index;
Assert(index < max_index, ExcIndexRange(index, 0, max_index));
if (index < n_matrices)
}
}
- if constexpr (running_in_debug_mode())
- {
- n_active_cells_pre = triangulation->n_active_cells();
- }
- else
- {
- (void)n_active_cells_pre;
- }
+ n_active_cells_pre = triangulation->n_active_cells();
}
Assert(out.size() == triangulation->n_active_cells(),
ExcDimensionMismatch(out.size(), triangulation->n_active_cells()));
}
- else
- {
- (void)n_active_cells_pre;
- }
// Transfer data of persisting cells.
for (const auto &persisting : persisting_cells_active_index)
dealii::hp::FESubfaceValues<dim, spacedim> &fe_subface_values,
const typename KellyErrorEstimator<dim, spacedim>::Strategy strategy)
{
- const auto neighbor = cell->neighbor(face_no);
- (void)neighbor;
+ const auto neighbor = cell->neighbor(face_no);
const unsigned int n_solution_vectors = solutions.size();
const auto face = cell->face(face_no);
}
const unsigned int n_components = dof_handler.get_fe(0).n_components();
- (void)n_components;
// sanity checks
Assert(solutions.size() > 0, ExcNoSolutions());
return;
const unsigned int dofs_per_cell = data.dof_indices.size();
- (void)dofs_per_cell;
-
Assert(data.cell_matrix.m() == dofs_per_cell, ExcInternalError());
Assert(data.cell_matrix.n() == dofs_per_cell, ExcInternalError());
Assert((right_hand_side == nullptr) ||
Assert(fe_is_hermite ||
matrix.n() == dof.n_boundary_dofs(boundary_functions),
ExcInternalError());
- (void)fe_is_hermite;
Assert(matrix.n() == matrix.m(), ExcInternalError());
Assert(matrix.n() == rhs_vector.size(), ExcInternalError());
for (unsigned int d = 0; d < dim; ++d)
Assert(vector_dofs.dof_indices[d] < n_dofs,
ExcInternalError());
- (void)n_dofs;
// we need the normal vector on this face. we know that
// it is a vector of length 1 but at least with higher
}
AssertDimension(n_total_constraints_found,
no_normal_flux_constraints.n_constraints());
- (void)n_total_constraints_found;
}
const Vector<Number> &vector,
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell)
{
- (void)tria;
AssertDimension(tria.n_active_cells(), vector.size());
return vector[cell->active_cell_index()];
}
spacedim,
typename VectorType::value_type>>> &)
{
- (void)evaluation_flags;
- (void)first_selected_component;
-
Assert(n_components == 1 && first_selected_component == 0,
ExcMessage(
"A cell-data vector can only have a single component."));
/* starting_offset = */ 0,
fe_values,
function_values);
- (void)offset;
Assert(offset == n_components, ExcInternalError());
FETools::convert_generalized_support_point_values_to_dof_values(
intergridmap.get_source_grid();
const DoFHandler<dim, spacedim> &dof_handler_2 =
intergridmap.get_destination_grid();
- (void)dof_handler_2;
Assert(
dof_handler_1.get_fe_collection() == dof_handler_2.get_fe_collection(),
std::enable_if_t<dealii::is_serial_vector<VectorType>::value == false>
subtract_mean_value(VectorType &v, const std::vector<bool> &p_select)
{
- (void)p_select;
Assert(p_select.empty(), ExcNotImplemented());
// In case of an empty boolean mask operate on the whole vector:
v.add(-v.mean_value());
Assert(&triangulation == &(dof_handler.get_triangulation()),
ExcMessage(
"Triangulation associated with the DoFHandler has changed!"));
- (void)triangulation;
// Skip if the DoFHandler has not been initialized yet.
if (dof_handler.get_fe_collection().empty())
(partition_zoltan | partition_metis | partition_zorder |
partition_custom_signal) &
settings;
- (void)partition_settings;
Assert(partition_settings == partition_auto ||
partition_settings == partition_metis ||
partition_settings == partition_zoltan ||
const unsigned int codim) const
{
Assert(codim <= dim, ExcImpossibleInDim(dim));
- (void)codim;
if (!dominate)
// if FE_Nothing does not dominate, there are no requirements
{
// Since this element has no dofs,
// the interpolation matrix is necessarily empty.
- (void)interpolation_matrix;
-
Assert(interpolation_matrix.m() == 0,
ExcDimensionMismatch(interpolation_matrix.m(), 0));
Assert(interpolation_matrix.n() == 0,
{
// since this element has no face dofs, the
// interpolation matrix is necessarily empty
- (void)interpolation_matrix;
-
Assert(interpolation_matrix.m() == 0,
ExcDimensionMismatch(interpolation_matrix.m(), 0));
Assert(interpolation_matrix.n() == 0,
{
// since this element has no face dofs, the
// interpolation matrix is necessarily empty
-
- (void)interpolation_matrix;
Assert(interpolation_matrix.m() == 0,
ExcDimensionMismatch(interpolation_matrix.m(), 0));
Assert(interpolation_matrix.n() == 0,
get_riaf_vector(points.size() - 1))
{
const int degree = points.size() - 1;
- (void)degree;
-
Assert(degree > 0,
ExcMessage("This element can only be used for polynomial degrees "
"at least zero"));
cell->face(5)->set_all_boundary_ids(1);
++count;
}
- (void)count;
Assert(count == 48, ExcInternalError());
}
else
default:
DEAL_II_ASSERT_UNREACHABLE();
}
- (void)twisted_data; // make the static analyzer happy
Assert(
!twisted_data,
ExcInvalidInputOrientation(
const bool colorize)
{
Assert(dim == 2 || dim == 3, ExcNotImplemented());
- (void)colorize;
- (void)n_cells;
Assert(inner_radius < outer_radius,
ExcMessage("outer_radius has to be bigger than inner_radius."));
if (n_shells == 0)
const double radius) {
(void)center;
(void)radial_vertex_tolerance;
- (void)face;
- (void)radius;
for (unsigned int vertex_n = 0;
vertex_n < GeometryInfo<dim>::vertices_per_face;
++vertex_n)
const FullMatrix<double> &matrix)
{
static const int space_dim = CellIterator::AccessorType::space_dimension;
- (void)space_dim;
AssertIndexRange(direction, space_dim);
if constexpr (running_in_debug_mode())
{
static const int dim = MeshType::dimension;
static const int space_dim = MeshType::space_dimension;
- (void)dim;
- (void)space_dim;
AssertIndexRange(direction, space_dim);
-
Assert(dim == space_dim, ExcNotImplemented());
// Loop over all cells on the highest level and collect all boundary
{
static const int dim = MeshType::dimension;
static const int space_dim = MeshType::space_dimension;
- (void)dim;
- (void)space_dim;
AssertIndexRange(direction, space_dim);
// Loop over all cells on the highest level and collect all boundary
const unsigned int n_mpi_ranks =
dealii::Utilities::MPI::n_mpi_processes(
partition.get_mpi_communicator());
- (void)n_mpi_ranks;
for (unsigned int i = 0; i < partition.locally_owned_size(); ++i)
{
const BlockSparsityPatternBase &s)
: BlockSparsityPatternBase()
{
- (void)s;
Assert(s.n_block_rows() == 0 && s.n_block_cols() == 0,
ExcMessage(
"This constructor can only be called if the provided argument "
, have_entries(false)
, rowset(0)
{
- (void)s;
Assert(s.rows == 0 && s.cols == 0,
ExcMessage(
"This constructor can only be called if the provided argument "
DynamicSparsityPattern &
DynamicSparsityPattern::operator=(const DynamicSparsityPattern &s)
{
- (void)s;
Assert(s.n_rows() == 0 && s.n_cols() == 0,
ExcMessage(
"This operator can only be called if the provided argument "
LAPACKFullMatrix<number> &
LAPACKFullMatrix<number>::operator=(const number d)
{
- (void)d;
Assert(d == number(0), ExcScalarAssignmentOnlyForZeroValue());
if (this->n_elements() != 0)
const types::blas_int mm = this->m();
const types::blas_int nn = this->n();
- (void)mm;
Assert(mm == nn, ExcDimensionMismatch(mm, nn));
number *const values = this->values.data();
MatrixBase &
MatrixBase::operator=(const value_type d)
{
- (void)d;
Assert(d == value_type(), ExcScalarAssignmentOnlyForZeroValue());
assert_is_compressed();
const size_type n,
const size_type locally_owned_size)
{
- (void)n;
AssertIndexRange(locally_owned_size, n + 1);
ghosted = false;
const size_type locally_owned_size,
const IndexSet &ghostnodes)
{
- (void)n;
AssertIndexRange(locally_owned_size, n + 1);
// If the size of the index set can be converted to a PetscInt then every
// index can also be converted
# ifdef DEAL_II_PETSC_WITH_HYPRE
initialize();
# else // DEAL_II_PETSC_WITH_HYPRE
- (void)pc;
Assert(false,
ExcMessage("Your PETSc installation does not include a copy of "
"the hypre package necessary for this preconditioner."));
"the MUMPS package necessary for this solver. You will need to configure "
"PETSc so that it includes MUMPS, recompile it, and then re-configure "
"and recompile deal.II as well."));
-
- // Cast to void to silence compiler warnings
(void)A;
(void)x;
(void)b;
&n_proc_cols_B);
Assert(n_local_rows_B == n_rows, ExcInternalError());
Assert(n_local_cols_B == n_columns, ExcInternalError());
- (void)n_local_cols_B;
int lda = std::max(1, n_local_rows_B);
int info = 0;
&n_proc_cols_B);
Assert(n_local_rows_B == n_rows, ExcInternalError());
Assert(n_local_cols_B == n_columns, ExcInternalError());
- (void)n_local_cols_B;
int lda = std::max(1, n_local_rows_B);
int info = 0;
SparsityPattern::SparsityPattern(const SparsityPattern &s)
: SparsityPattern()
{
- (void)s;
Assert(s.empty(),
ExcMessage(
"This constructor can only be called if the provided argument "
SparsityPattern &
SparsityPattern::operator=(const SparsityPattern &s)
{
- (void)s;
Assert(s.empty(),
ExcMessage(
"This operator can only be called if the provided argument "
cell_weights.empty(),
ExcMessage(
"The cell weighting functionality for Zoltan has not yet been implemented."));
- (void)cell_weights;
// MPI environment must have been initialized by this point.
std::unique_ptr<Zoltan> zz = std::make_unique<Zoltan>(MPI_COMM_SELF);
export_local_ids,
export_procs,
export_to_part);
- (void)rc;
// check for error code in partitioner
Assert(rc == ZOLTAN_OK, ExcInternalError());
num_objects,
global_ids.data(),
color_exp.data());
-
- (void)rc;
// Check for error code
Assert(rc == ZOLTAN_OK, ExcInternalError());
block_sparsity_pattern.n_block_cols()));
const size_type n_block_rows = epetra_maps.size();
- (void)n_block_rows;
-
Assert(n_block_rows == block_sparsity_pattern.n_block_rows(),
ExcDimensionMismatch(n_block_rows,
block_sparsity_pattern.n_block_rows()));
ExcDimensionMismatch(n_block_rows,
block_sparsity_pattern.n_block_cols()));
-
// Call the other basic reinit function, ...
reinit(block_sparsity_pattern.n_block_rows(),
block_sparsity_pattern.n_block_cols());
{
const int ierr = vector->PutScalar(0.);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
}
}
const int ierr =
vector->Import(V.trilinos_vector(), data_exchange, Insert);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
}
else
vector = std::make_unique<Epetra_FEVector>(V.trilinos_vector());
const int ierr = vector->PutScalar(s);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
return *this;
}
{
const int ierr = vector->Update(1., V.trilinos_vector(), 1.);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
}
else
{
data_exchange,
Epetra_AddLocalAlso);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
}
return *this;
double result(0.);
const int ierr = vector->Dot(V.trilinos_vector(), &result);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
return result;
}
const int ierr = vector->Update(a, V.trilinos_vector(), 1.);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
}
const int ierr =
vector->Update(a, V.trilinos_vector(), b, W.trilinos_vector(), 1.);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
}
const int ierr =
vector->Multiply(1.0, scaling_factors.trilinos_vector(), *vector, 0.0);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
}
// Otherwise, just update
int ierr = vector->Update(a, V.trilinos_vector(), 0.);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
}
}
int ierr = vector->MeanValue(&mean_value);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
return mean_value;
}
double norm(0.);
int ierr = vector->Norm1(&norm);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
return norm;
}
double norm(0.);
int ierr = vector->Norm2(&norm);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
return norm;
}
double norm(0.);
int ierr = vector->NormInf(&norm);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
return norm;
}
int ierr = vector->ExtractView(&val, &leading_dimension);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr;
out.precision(precision);
if (scientific)
out.setf(std::ios::scientific, std::ios::floatfield);
if (constant_modes_dimension > 0)
{
const size_type global_size = TrilinosWrappers::n_global_rows(matrix);
- (void)global_length; // work around compiler warning about unused
- // function in release mode
Assert(global_size ==
static_cast<size_type>(TrilinosWrappers::global_length(
distributed_constant_modes)),
static_cast<double>(constant_modes[d][mode_index]);
}
}
- (void)expected_mode_size;
parameter_list.set("null space: type", "pre-computed");
parameter_list.set("null space: dimension",
TrilinosWrappers::global_length(
distributed_constant_modes)));
- (void)n_relevant_rows;
- (void)global_length;
-
// Reshape null space as a contiguous vector of doubles so that
// Trilinos can read from it.
for (size_type d = 0; d < constant_modes_dimension; ++d)
rhs_n_entries,
rhs_value_ptr,
rhs_index_ptr);
- (void)ierr;
Assert(ierr == 0, ExcTrilinosError(ierr));
ierr = matrix->ExtractMyRowView(row_local,
// check whether we got the number of columns right.
AssertDimension(sparsity_pattern.n_cols(),
TrilinosWrappers::n_global_cols(*graph));
- (void)n_global_cols;
// And now finally generate the matrix.
matrix = std::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
{
Epetra_Export exporter(nonlocal_graph->RowMap(), row_space_map);
int ierr = graph->Export(*nonlocal_graph, exporter, Add);
- (void)ierr;
Assert(ierr == 0, ExcTrilinosError(ierr));
}
int num_entries;
const int ierr =
matrix->ExtractMyRowView(local_row, num_entries, values, col_indices);
- (void)ierr;
Assert(ierr == 0, ExcTrilinosError(ierr));
nnz_extracted,
values,
col_indices);
- (void)ierr;
Assert(ierr == 0, ExcTrilinosError(ierr));
Assert(nnz_present == nnz_extracted,
nnz_extracted,
values,
col_indices);
- (void)ierr;
Assert(ierr == 0, ExcTrilinosError(ierr));
Assert(nnz_present == nnz_extracted,
SparseMatrix &
SparseMatrix::operator=(const double d)
{
- (void)d;
Assert(d == 0, ExcScalarAssignmentOnlyForZeroValue());
compress(VectorOperation::unknown); // TODO: why do we do this? Should we
// not check for is_compressed?
rhs_n_entries,
rhs_value_ptr,
rhs_index_ptr);
- (void)ierr;
Assert(ierr == 0, ExcTrilinosError(ierr));
ierr =
{
const int ierr = matrix->Scale(a);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr; // removes -Wunused-variable in optimized mode
return *this;
}
const int ierr = matrix->Scale(factor);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr; // removes -Wunused-variable in optimized mode
return *this;
}
"Are you trying to put the product of the "
"matrix with a vector into a vector that has "
"ghost elements?"));
- (void)m;
- (void)in;
- (void)out;
}
} // namespace SparseMatrixImplementation
} // namespace internal
{
Assert(&src != &dst, ExcSourceEqualsDestination());
Assert(matrix->Filled(), ExcMatrixNotCompressed());
- (void)src;
- (void)dst;
internal::SparseMatrixImplementation::check_vector_map_equality(*matrix,
src,
const int ierr = matrix->Multiply(false, tril_src, tril_dst);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr; // removes -Wunused-variable in optimized mode
}
const int ierr = matrix->Multiply(true, tril_src, tril_dst);
Assert(ierr == 0, ExcTrilinosError(ierr));
- (void)ierr; // removes -Wunused-variable in optimized mode
}
{
const int ierr =
matrix->ExtractMyRowView(i, num_entries, values, indices);
- (void)ierr;
Assert(ierr == 0, ExcTrilinosError(ierr));
for (TrilinosWrappers::types::int_type j = 0; j < num_entries; ++j)
AssertDimension(i_local_size, first_op_init_map.NumMyPoints());
const Epetra_Map &second_op_init_map = second_op.OperatorDomainMap();
AssertDimension(i_local_size, second_op_init_map.NumMyPoints());
- (void)second_op_init_map;
Intermediate tril_int(View,
first_op_init_map,
const_cast<TrilinosScalar *>(i->begin()),
AssertDimension(i_local_size, first_op_init_map.NumMyPoints());
const Epetra_Map &second_op_init_map = second_op.OperatorRangeMap();
AssertDimension(i_local_size, second_op_init_map.NumMyPoints());
- (void)second_op_init_map;
Intermediate tril_int(View,
first_op_init_map,
const_cast<TrilinosScalar *>(i->begin()),
AssertDimension(i_local_size, first_op_init_map.NumMyPoints());
const Epetra_Map &second_op_init_map = second_op.OperatorRangeMap();
AssertDimension(i_local_size, second_op_init_map.NumMyPoints());
- (void)second_op_init_map;
Intermediate tril_int(View,
first_op_init_map,
const_cast<TrilinosScalar *>(i->begin()),
AssertDimension(i_local_size, first_op_init_map.NumMyPoints());
const Epetra_Map &second_op_init_map = second_op.OperatorDomainMap();
AssertDimension(i_local_size, second_op_init_map.NumMyPoints());
- (void)second_op_init_map;
Intermediate tril_int(View,
first_op_init_map,
const_cast<TrilinosScalar *>(i->begin()),
AssertDimension(i_local_size, first_op_init_map.NumMyPoints());
const Epetra_Map &second_op_init_map = second_op.OperatorRangeMap();
AssertDimension(i_local_size, second_op_init_map.NumMyPoints());
- (void)second_op_init_map;
Intermediate tril_int(View,
first_op_init_map,
const_cast<TrilinosScalar *>(i->begin()),
AssertDimension(i_local_size, first_op_init_map.NumMyPoints());
const Epetra_Map &second_op_init_map = second_op.OperatorDomainMap();
AssertDimension(i_local_size, second_op_init_map.NumMyPoints());
- (void)second_op_init_map;
Intermediate tril_int(View,
first_op_init_map,
const_cast<TrilinosScalar *>(i->begin()),
AssertDimension(i_local_size, first_op_init_map.NumMyPoints());
const Epetra_Map &second_op_init_map = second_op.OperatorDomainMap();
AssertDimension(i_local_size, second_op_init_map.NumMyPoints());
- (void)second_op_init_map;
Intermediate tril_int(View,
first_op_init_map,
const_cast<TrilinosScalar *>(i->begin()),
AssertDimension(i_local_size, first_op_init_map.NumMyPoints());
const Epetra_Map &second_op_init_map = second_op.OperatorRangeMap();
AssertDimension(i_local_size, second_op_init_map.NumMyPoints());
- (void)second_op_init_map;
Intermediate tril_int(View,
first_op_init_map,
const_cast<TrilinosScalar *>(i->begin()),
, graph(
new Epetra_FECrsGraph(View, *column_space_map, *column_space_map, 0))
{
- (void)input_sparsity;
Assert(input_sparsity.n_rows() == 0,
ExcMessage(
"Copy constructor only works for empty sparsity patterns."));
int ierr = graph->ExtractGlobalRowView(trilinos_i,
nnz_extracted,
col_indices);
- (void)ierr;
Assert(ierr == 0, ExcTrilinosError(ierr));
Assert(nnz_present == nnz_extracted,
ExcDimensionMismatch(nnz_present, nnz_extracted));
// an error.
int ierr =
graph->ExtractMyRowView(trilinos_i, nnz_extracted, col_indices);
- (void)ierr;
Assert(ierr == 0, ExcTrilinosError(ierr));
Assert(nnz_present == nnz_extracted,
{
// old and new vectors have exactly the same map, i.e. size and
// parallel distribution
- int ierr;
- ierr = vector->GlobalAssemble(last_action);
- (void)ierr;
+ int ierr = vector->GlobalAssemble(last_action);
Assert(ierr == 0, ExcTrilinosError(ierr));
ierr = vector->PutScalar(0.0);
else
{
const int ierr = vector->PutScalar(0.);
- (void)ierr;
Assert(ierr == 0, ExcTrilinosError(ierr));
}
const std::vector<unsigned int> &constraint_pool_row_index,
const std::vector<unsigned char> &irregular_cells)
{
- (void)constraint_pool_row_index;
-
// first reorder the active FE index.
const bool have_hp = dofs_per_cell.size() > 1;
if (cell_active_fe_index.size() > 0)
const bool keep_constrained_dofs)
{
const types::global_dof_index n_dofs = dof.n_dofs(level);
- (void)n_dofs;
Assert(sparsity.n_rows() == n_dofs,
ExcDimensionMismatch(sparsity.n_rows(), n_dofs));
const bool keep_constrained_dofs)
{
const types::global_dof_index n_dofs = dof.n_dofs(level);
- (void)n_dofs;
Assert(sparsity.n_rows() == n_dofs,
ExcDimensionMismatch(sparsity.n_rows(), n_dofs));
const types::global_dof_index fine_dofs = dof.n_dofs(level);
const types::global_dof_index coarse_dofs = dof.n_dofs(level - 1);
- (void)fine_dofs;
- (void)coarse_dofs;
// Matrix maps from fine level to coarse level
-
Assert(sparsity.n_rows() == coarse_dofs,
ExcDimensionMismatch(sparsity.n_rows(), coarse_dofs));
Assert(sparsity.n_cols() == fine_dofs,
const FiniteElement<dim> &fe = dof.get_fe();
const types::global_dof_index n_dofs = dof.n_dofs(level);
const unsigned int n_comp = fe.n_components();
- (void)n_dofs;
- (void)n_comp;
Assert(sparsity.n_rows() == n_dofs,
ExcDimensionMismatch(sparsity.n_rows(), n_dofs));
const types::global_dof_index fine_dofs = dof.n_dofs(level);
const types::global_dof_index coarse_dofs = dof.n_dofs(level - 1);
- (void)fine_dofs;
- (void)coarse_dofs;
// Matrix maps from fine level to coarse level
-
Assert(sparsity.n_rows() == coarse_dofs,
ExcDimensionMismatch(sparsity.n_rows(), coarse_dofs));
Assert(sparsity.n_cols() == fine_dofs,
const unsigned int level)
{
const types::global_dof_index n_dofs = dof.n_dofs(level);
- (void)n_dofs;
-
Assert(sparsity.n_rows() == n_dofs,
ExcDimensionMismatch(sparsity.n_rows(), n_dofs));
Assert(sparsity.n_cols() == n_dofs,
{
Assert((from_level >= 1) && (from_level <= prolongation_matrices.size()),
ExcIndexRange(from_level, 1, prolongation_matrices.size() + 1));
- (void)from_level;
prolongation_matrices[from_level - 1]->Tvmult_add(dst, src);
}
names.size(), dof_handler->get_fe(0).n_components()));
for (const auto &name : names)
{
- (void)name;
Assert(name.find_first_not_of("abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789_<>()") == std::string::npos,
for (; dof != endd; ++dof)
{
Assert(dof->first < n_dofs, ExcInternalError());
- (void)n_dofs;
// get global index and index
// in the block in which this
const bool eliminate_columns)
{
Assert(eliminate_columns == false, ExcNotImplemented());
- (void)eliminate_columns;
-
Assert(matrix.n() == right_hand_side.size(),
ExcDimensionMismatch(matrix.n(), right_hand_side.size()));
Assert(matrix.n() == solution.size(),
component_mask.find(vector_name);
Assert(mask != component_mask.end(), ExcMessage("vector_name not in class"));
unsigned int n_stored = mask->second.n_selected_components();
- (void)n_stored;
Assert(component_names.size() == n_stored,
ExcDimensionMismatch(component_names.size(), n_stored));