(const Bytef *) &data[0],
data.size() * sizeof(T),
Z_BEST_COMPRESSION);
+ (void)err;
Assert (err == Z_OK, ExcInternalError());
// now encode the compression header
patch != patches.end(); ++patch)
{
const unsigned int n_subdivisions = patch->n_subdivisions;
+ (void)n_subdivisions;
Assert ((patch->data.n_rows() == n_data_sets && !patch->points_are_available) ||
(patch->data.n_rows() == n_data_sets+spacedim && patch->points_are_available),
Assert (spacedim==2, ExcNotImplemented());
const unsigned int n_data_sets = data_names.size();
+ (void)n_data_sets;
// write preamble
if (true)
std::vector<std::vector<double> > &values) const
{
unsigned int n = points.size();
+ (void)n;
Assert(values.size() == dim+1, ExcDimensionMismatch(values.size(), dim+1));
for (unsigned int d=0; d<dim+1; ++d)
Assert(values[d].size() == n, ExcDimensionMismatch(values[d].size(), n));
std::vector<std::vector<double> > &values) const
{
unsigned int n = points.size();
+ (void)n;
Assert(values.size() == 2+1, ExcDimensionMismatch(values.size(), 2+1));
for (unsigned int d=0; d<2+1; ++d)
Assert(values[d].size() == n, ExcDimensionMismatch(values[d].size(), n));
FourierCosineFunction<dim>::value (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1));
return std::cos(fourier_coefficients * p);
}
FourierCosineFunction<dim>::gradient (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1));
return -fourier_coefficients * std::sin(fourier_coefficients * p);
}
FourierCosineFunction<dim>::laplacian (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1));
return (fourier_coefficients * fourier_coefficients) * (-std::cos(fourier_coefficients * p));
}
FourierSineFunction<dim>::value (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1));
return std::sin(fourier_coefficients * p);
}
FourierSineFunction<dim>::gradient (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1));
return fourier_coefficients * std::cos(fourier_coefficients * p);
}
FourierSineFunction<dim>::laplacian (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1));
return (fourier_coefficients * fourier_coefficients) * (-std::sin(fourier_coefficients * p));
}
FourierSineSum<dim>::value (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1));
const unsigned int n = weights.size();
FourierSineSum<dim>::gradient (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1));
const unsigned int n = weights.size();
FourierSineSum<dim>::laplacian (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1));
const unsigned int n = weights.size();
FourierCosineSum<dim>::value (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1));
const unsigned int n = weights.size();
FourierCosineSum<dim>::gradient (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1));
const unsigned int n = weights.size();
FourierCosineSum<dim>::laplacian (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1));
const unsigned int n = weights.size();
Monomial<dim>::value (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component<this->n_components,
ExcIndexRange(component, 0, this->n_components)) ;
Monomial<dim>::gradient (const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component==0, ExcIndexRange(component,0,1)) ;
Tensor<1,dim> r;
InterpolatedTensorProductGridData<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component == 0,
ExcMessage ("This is a scalar function object, the component can only be zero."));
InterpolatedUniformGridData<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
+ (void)component;
Assert (component == 0,
ExcMessage ("This is a scalar function object, the component can only be zero."));
GeometryInfo<1>::line_refinement_case(const RefinementCase<1> &cell_refinement_case,
const unsigned int line_no)
{
+ (void)line_no;
const unsigned int dim = 1;
+ (void)dim;
Assert(cell_refinement_case<RefinementCase<dim>::isotropic_refinement+1,
ExcIndexRange(cell_refinement_case, 0, RefinementCase<dim>::isotropic_refinement+1));
Assert(line_no<GeometryInfo<dim>::lines_per_cell,
RefinementCase<1>
GeometryInfo<1>::min_cell_refinement_case_for_line_refinement(const unsigned int line_no)
{
+ (void)line_no;
Assert(line_no==0, ExcIndexRange(line_no,0,1));
return RefinementCase<1>::cut_x;
GeometryInfo<2>::min_cell_refinement_case_for_line_refinement(const unsigned int line_no)
{
const unsigned int dim = 2;
+ (void)dim;
Assert(line_no<GeometryInfo<dim>::lines_per_cell,
ExcIndexRange(line_no, 0, GeometryInfo<dim>::lines_per_cell));
const bool, const bool, const bool,
const RefinementCase<0> &)
{
+ (void)subface;
Assert (face<faces_per_cell, ExcIndexRange(face, 0, faces_per_cell));
Assert (subface<max_children_per_face,
ExcIndexRange(subface, 0, max_children_per_face));
GeometryInfo<1>::line_to_cell_vertices (const unsigned int line,
const unsigned int vertex)
{
+ (void)line;
Assert (line<lines_per_cell, ExcIndexRange(line, 0, lines_per_cell));
Assert (vertex<2, ExcIndexRange(vertex, 0, 2));
const unsigned int line,
const bool, const bool, const bool)
{
+ (void)face;
+ (void)line;
Assert (face+1<faces_per_cell+1, ExcIndexRange(face, 0, faces_per_cell));
Assert (line+1<lines_per_face+1, ExcIndexRange(line, 0, lines_per_face));
const unsigned int line,
const bool, const bool, const bool)
{
+ (void)line;
Assert (face<faces_per_cell, ExcIndexRange(face, 0, faces_per_cell));
Assert (line<lines_per_face, ExcIndexRange(line, 0, lines_per_face));
int *len,
MPI_Datatype *)
{
+ (void)len;
const MinMaxAvg *in_lhs = static_cast<const MinMaxAvg *>(in_lhs_);
MinMaxAvg *inout_rhs = static_cast<MinMaxAvg *>(inout_rhs_);
const unsigned int max_num_threads)
{
static bool constructor_has_already_run = false;
+ (void)constructor_has_already_run;
Assert (constructor_has_already_run == false,
ExcMessage ("You can only create a single object of this class "
"in a program since it initializes the MPI system."));
:
counter (0),
object_info (0)
-{}
+{
+ // this has to go somewhere to avoid an extra warning.
+ (void)unknown_subscriber;
+}
+
Subscriptor::Subscriptor (const Subscriptor &)
else
it->second++;
+# else
+ (void)id;
# endif
#else
(void)id;
for (unsigned int i=0; i<N; ++i)
diagonal_sum += std::fabs(tmp.data[i][i]);
const double typical_diagonal_element = diagonal_sum/N;
+ (void)typical_diagonal_element;
unsigned int p[N];
for (unsigned int i=0; i<N; ++i)
ConstantTensorFunction<rank, dim, Number>::value_list (const std::vector<Point<dim> > &points,
std::vector<typename TensorFunction<rank, dim, Number>::value_type> &values) const
{
+ (void)points;
Assert (values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
ConstantTensorFunction<rank, dim, Number>::gradient_list (const std::vector<Point<dim> > &points,
std::vector<typename TensorFunction<rank, dim, Number>::gradient_type> &gradients) const
{
+ (void)points;
Assert (gradients.size() == points.size(),
ExcDimensionMismatch(gradients.size(), points.size()));
num_vtt = std::accumulate (vertex_touch_count.begin(),
vertex_touch_count.end(),
0);
+ (void)num_vtt;
Assert (connectivity->ctt_offset[triangulation.n_vertices()] ==
num_vtt,
ExcInternalError());
// many non-artificial cells as parallel_forest->local_num_quadrants)
{
const unsigned int total_local_cells = this->n_active_cells();
+ (void)total_local_cells;
if (Utilities::MPI::n_mpi_processes (mpi_communicator) == 1)
Assert (static_cast<unsigned int>(parallel_forest->local_num_quadrants) ==
++it, ++buffer, ++idx)
{
const unsigned int num_cells = it->second.tree_index.size();
+ (void)num_cells;
destinations.push_back(it->first);
Assert(num_cells==it->second.quadrants.size(), ExcInternalError());
template<int dim, int spacedim>
void DoFHandler<dim, spacedim>::distribute_mg_dofs (const FiniteElement<dim, spacedim> &fe)
{
+ (void)fe;
Assert(levels.size()>0, ExcMessage("Distribute active DoFs using distribute_dofs() before calling distribute_mg_dofs()."));
const FiniteElement<dim, spacedim> *old_fe = selected_fe;
+ (void)old_fe;
Assert(old_fe == &fe, ExcMessage("You are required to use the same FE for level and active DoFs!") );
clear_mg_space();
++it, ++buffer, ++idx)
{
const unsigned int num_cells = it->second.tree_index.size();
+ (void)num_cells;
Assert(num_cells==it->second.quadrants.size(), ExcInternalError());
Assert(num_cells>0, ExcInternalError());
++it, ++buffer, ++idx)
{
const unsigned int num_cells = it->second.tree_index.size();
+ (void)num_cells;
Assert(num_cells==it->second.quadrants.size(), ExcInternalError());
Assert(num_cells>0, ExcInternalError());
const unsigned int local_index,
const types::global_dof_index global_index)
{
+ (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 bool reversed_numbering,
const bool use_constraints)
{
+ (void)use_constraints;
Assert (use_constraints == false, ExcNotImplemented());
// the following code is pretty
const unsigned int dim = DH::dimension;
const unsigned int spacedim = DH::space_dimension;
const Triangulation<dim,spacedim> &tria = dof_handler.get_tria();
+ (void)tria;
AssertDimension (cell_data.size(), tria.n_active_cells());
AssertDimension (dof_data.size(), dof_handler.n_dofs());
std::vector<bool> &selected_dofs)
{
const FiniteElement<dim,spacedim> &fe = dof.get_fe();
+ (void)fe;
Assert(component_mask.represents_n_components(fe.n_components()),
ExcMessage ("The given component mask is not sized correctly to represent the "
std::vector<bool> &selected_dofs)
{
const FiniteElement<dim,spacedim> &fe = dof.begin_active()->get_fe();
+ (void)fe;
Assert(component_mask.represents_n_components(fe.n_components()),
ExcMessage ("The given component mask is not sized correctly to represent the "
const ComponentMask &component_mask)
{
static const int space_dim = DH::space_dimension;
+ (void)space_dim;
Assert (0<=direction && direction<space_dim,
ExcIndexRange (direction, 0, space_dim));
{
static const int dim = DH::dimension;
static const int space_dim = DH::space_dimension;
+ (void)dim;
+ (void)space_dim;
Assert (0<=direction && direction<space_dim,
ExcIndexRange (direction, 0, space_dim));
fine_grid, fine_component,
coarse_to_fine_grid_map,
weights, weight_mapping);
+ (void)n_parameters_on_fine_grid;
// global numbers of dofs
const types::global_dof_index n_coarse_dofs = coarse_grid.n_dofs(),
const types::subdomain_id subdomain_id)
{
const types::global_dof_index n_dofs = dof.n_dofs();
+ (void)n_dofs;
Assert (sparsity.n_rows() == n_dofs,
ExcDimensionMismatch (sparsity.n_rows(), n_dofs));
const types::subdomain_id subdomain_id)
{
const types::global_dof_index n_dofs = dof.n_dofs();
+ (void)n_dofs;
Assert (sparsity.n_rows() == n_dofs,
ExcDimensionMismatch (sparsity.n_rows(), n_dofs));
{
const types::global_dof_index n_dofs_row = dof_row.n_dofs();
const types::global_dof_index n_dofs_col = dof_col.n_dofs();
+ (void)n_dofs_row;
+ (void)n_dofs_col;
Assert (sparsity.n_rows() == n_dofs_row,
ExcDimensionMismatch (sparsity.n_rows(), n_dofs_row));
}
const types::global_dof_index n_dofs = dof.n_dofs();
+ (void)n_dofs;
AssertDimension (dof_to_boundary_mapping.size(), n_dofs);
AssertDimension (sparsity.n_rows(), dof.n_boundary_dofs());
}
const types::global_dof_index n_dofs = dof.n_dofs();
+ (void)n_dofs;
AssertDimension (dof_to_boundary_mapping.size(), n_dofs);
Assert (boundary_ids.find(numbers::internal_face_boundary_id) == boundary_ids.end(),
{
const types::global_dof_index n_dofs = dof.n_dofs();
+ (void)n_dofs;
AssertDimension (sparsity.n_rows(), n_dofs);
AssertDimension (sparsity.n_cols(), n_dofs);
// do the error checking and frame code here, and then pass on to more
// specialized functions in the internal namespace
const types::global_dof_index n_dofs = dof.n_dofs();
+ (void)n_dofs;
const unsigned int n_comp = dof.get_fe().n_components();
+ (void)n_comp;
Assert (sparsity.n_rows() == n_dofs,
ExcDimensionMismatch (sparsity.n_rows(), n_dofs));
const FullMatrix<double> &
FiniteElement<dim,spacedim>::constraints (const internal::SubfaceCase<dim> &subface_case) const
{
+ (void)subface_case;
Assert (subface_case==internal::SubfaceCase<dim>::case_isotropic,
ExcMessage("Constraints for this element are only implemented "
"for the case that faces are refined isotropically "
const FiniteElement<dim,spacedim> &
FiniteElement<dim,spacedim>::base_element(const unsigned int index) const
{
+ (void)index;
Assert (index==0, ExcIndexRange(index,0,1));
// This function should not be
// called for a system element
// case, both elements have no dofs on their faces and the face
// interpolation matrix is necessarily empty -- i.e. there isn't much we
// need to do here.
+ (void)interpolation_matrix;
typedef FiniteElement<dim,spacedim> FE;
typedef FE_DGP<dim,spacedim> FEDGP;
AssertThrow ((x_source_fe.get_name().find ("FE_DGP<") == 0)
// case, both elements have no dofs on their faces and the face
// interpolation matrix is necessarily empty -- i.e. there isn't much we
// need to do here.
+ (void)interpolation_matrix;
typedef FiniteElement<dim,spacedim> FE;
typedef FE_DGP<dim,spacedim> FEDGP;
AssertThrow ((x_source_fe.get_name().find ("FE_DGP<") == 0)
// matrix is simple
const unsigned int m=interpolation_matrix.m();
const unsigned int n=interpolation_matrix.n();
+ (void)m;
+ (void)n;
Assert (m == this->dofs_per_cell, ExcDimensionMismatch (m, this->dofs_per_cell));
Assert (n == source_dgp_monomial->dofs_per_cell,
ExcDimensionMismatch (n, source_dgp_monomial->dofs_per_cell));
// faces and the face interpolation matrix
// is necessarily empty -- i.e. there isn't
// much we need to do here.
+ (void)interpolation_matrix;
AssertThrow ((x_source_fe.get_name().find ("FE_DGPMonomial<") == 0)
||
(dynamic_cast<const FE_DGPMonomial<dim>*>(&x_source_fe) != 0),
// faces and the face interpolation matrix
// is necessarily empty -- i.e. there isn't
// much we need to do here.
+ (void)interpolation_matrix;
AssertThrow ((x_source_fe.get_name().find ("FE_DGPMonomial<") == 0)
||
(dynamic_cast<const FE_DGPMonomial<dim>*>(&x_source_fe) != 0),
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 polynomial_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 polynomial_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 polynomial_space.compute_grad_grad(i, p);
// faces and the face interpolation matrix
// is necessarily empty -- i.e. there isn't
// much we need to do here.
+ (void)interpolation_matrix;
typedef FiniteElement<dim,spacedim> FEE;
AssertThrow ((x_source_fe.get_name().find ("FE_DGPNonparametric<") == 0)
||
// faces and the face interpolation matrix
// is necessarily empty -- i.e. there isn't
// much we need to do here.
+ (void)interpolation_matrix;
typedef FiniteElement<dim,spacedim> FEE;
AssertThrow ((x_source_fe.get_name().find ("FE_DGPNonparametric<") == 0)
||
// faces and the face interpolation matrix
// is necessarily empty -- i.e. there isn't
// much we need to do here.
+ (void)interpolation_matrix;
typedef FiniteElement<dim,spacedim> FE;
AssertThrow ((dynamic_cast<const FE_DGQ<dim, spacedim>*>(&x_source_fe) != 0),
typename FE::ExcInterpolationNotImplemented());
// faces and the face interpolation matrix
// is necessarily empty -- i.e. there isn't
// much we need to do here.
+ (void)interpolation_matrix;
typedef FiniteElement<dim, spacedim> FE;
AssertThrow ((dynamic_cast<const FE_DGQ<dim, spacedim>*>(&x_source_fe) != 0),
typename FE::ExcInterpolationNotImplemented());
const unsigned int /*subface*/,
FullMatrix<double> &interpolation_matrix) const
{
+ (void)x_source_fe;
Assert (interpolation_matrix.n() == this->dofs_per_face,
ExcDimensionMismatch (interpolation_matrix.n(),
this->dofs_per_face));
const UpdateFlags flags(data->update_flags);
const unsigned int n_q_points = quadrature.size();
AssertDimension(n_q_points, 1);
+ (void)n_q_points;
// No derivatives of this element are implemented.
if (flags & update_gradients || flags & update_hessians)
v_in(k) = this->poly_space.compute_value(i, p);
}
const double result = H.least_squares(v_out, v_in);
+ (void)result;
Assert(result < 1e-12, FETools::ExcLeastSquaresError (result));
for (unsigned int j = 0; j < source_fe->dofs_per_face; ++j)
FE_Nothing<dim,spacedim>::shape_value (const unsigned int /*i*/,
const Point<dim> & /*p*/) const
{
+ (void)zero_dof_message;
Assert(false,ExcMessage(zero_dof_message));
return 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(),
// 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));
std::vector<bool> (1, false))
{
const unsigned int degree = points.size()-1;
+ (void)degree;
Assert (degree > 0,
ExcMessage ("This element can only be used for polynomial degrees "
"at least zero"));
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 "
// we will be able to do the work
const FE_Q_Hierarchical<dim> &source_fe
= dynamic_cast<const FE_Q_Hierarchical<dim>&>(x_source_fe);
+ (void)source_fe;
// Make sure, that the element,
// for which the DoFs should be
// solve the least squares
// problem.
const double result = H.least_squares (v_fine, v_coarse);
+ (void)result;
Assert (result < 1.e-12, ExcLeastSquaresError (result));
// Copy into the result
// solve the least squares
// problem.
const double result = H.least_squares(v_fine, v_coarse);
+ (void)result;
Assert (result < 1.e-12, ExcLeastSquaresError(result));
// Copy into the result
if (pos2-pos1 == 2)
{
const char dimchar = '0' + dim;
+ (void)dimchar;
if (name.at(pos1+1) != 'd')
Assert (name.at(pos1+1) == dimchar,
ExcInvalidFEDimension(name.at(pos1+1), dim));
endc1 = dof1.end();
typename DH2<dim,spacedim>::active_cell_iterator cell2 = dof2.begin_active(),
endc2 = dof2.end();
+ (void)endc2;
std::vector<types::global_dof_index> dofs;
dofs.reserve (DoFTools::max_dofs_per_cell (dof2));
// Assert that we can write all components into the result vectors
const unsigned result_components = n_components * component_multiple;
+ (void)result_components;
if (quadrature_points_fastest)
{
AssertDimension(values.size(), result_components);
// Assert that we can write all components into the result vectors
const unsigned result_components = n_components * component_multiple;
+ (void)result_components;
if (quadrature_points_fastest)
{
AssertDimension(derivatives.size(), result_components);
// Assert that we can write all components into the result vectors
const unsigned result_components = n_components * component_multiple;
+ (void)result_components;
if (quadrature_points_fastest)
{
AssertDimension(laplacians.size(), result_components);
std::vector<Point<1> > &) const
{
const unsigned int dim = 1;
+ (void)dim;
Assert (dim > 1, ExcImpossibleInDim(dim));
}
std::vector<Point<1> > &) const
{
const unsigned int dim = 1;
+ (void)dim;
Assert (dim > 2, ExcImpossibleInDim(dim));
}
std::vector<Point<2> > &) const
{
const unsigned int dim = 2;
+ (void)dim;
Assert (dim > 2, ExcImpossibleInDim(dim));
}
const std::vector<Point<1> > &unit_points,
typename dealii::MappingQ1<1,spacedim>::InternalData &data)
{
+ (void)n_shape_functions;
const unsigned int n_points=unit_points.size();
for (unsigned int k = 0 ; k < n_points ; ++k)
{
const std::vector<Point<2> > &unit_points,
typename dealii::MappingQ1<2,spacedim>::InternalData &data)
{
+ (void)n_shape_functions;
const unsigned int n_points=unit_points.size();
for (unsigned int k = 0 ; k < n_points ; ++k)
{
const std::vector<Point<3> > &unit_points,
typename dealii::MappingQ1<3,spacedim>::InternalData &data)
{
+ (void)n_shape_functions;
const unsigned int n_points=unit_points.size();
for (unsigned int k = 0 ; k < n_points ; ++k)
{
else
{
const unsigned int codim = spacedim-dim;
+ (void)codim;
if (update_flags & update_normal_vectors)
{
transform_unit_to_real_cell_internal (const InternalData &data) const
{
const unsigned int n_mapping_points=data.mapping_support_points.size();
+ (void)n_mapping_points;
AssertDimension (data.shape_values.size(), n_mapping_points);
// use now the InternalData to
InternalData &mdata) const
{
const unsigned int n_shapes=mdata.shape_values.size();
+ (void)n_shapes;
Assert(n_shapes!=0, ExcInternalError());
AssertDimension (mdata.shape_derivatives.size(), n_shapes);
const unsigned int n_shapes=mdata.shape_values.size();
+ (void)n_shapes;
Assert(n_shapes!=0, ExcInternalError());
Assert(mdata.shape_derivatives.size()==n_shapes, ExcInternalError());
Assert(mdata.shape_second_derivatives.size()==n_shapes, ExcInternalError());
const types::global_dof_index n_dofs = euler_dof_handler->n_dofs();
const types::global_dof_index vector_size = euler_vector->size();
+ (void)n_dofs;
+ (void)vector_size;
AssertDimension(vector_size,n_dofs);
const unsigned int n,
const bool colorize)
{
+ (void)colorize;
Assert ((inner_radius > 0) && (inner_radius < outer_radius),
ExcInvalidRadii ());
Assert(colorize == false, ExcNotImplemented());
const parallel::distributed::Triangulation<dim, spacedim1> *pt =
dynamic_cast<const parallel::distributed::Triangulation<dim, spacedim1> *>(&in_tria);
+ (void)pt;
Assert (pt == NULL,
ExcMessage("Cannot use this function on parallel::distributed::Triangulation."));
const std::vector<unsigned int> &first_vector_components)
{
static const int space_dim = CellIterator::AccessorType::space_dimension;
+ (void)space_dim;
Assert (0<=direction && direction<space_dim,
ExcIndexRange (direction, 0, space_dim));
{
static const int dim = CONTAINER::dimension;
static const int space_dim = CONTAINER::space_dimension;
+ (void)dim;
+ (void)space_dim;
Assert (0<=direction && direction<space_dim,
ExcIndexRange (direction, 0, space_dim));
{
static const int dim = CONTAINER::dimension;
static const int space_dim = CONTAINER::space_dimension;
+ (void)dim;
+ (void)space_dim;
Assert (0<=direction && direction<space_dim,
ExcIndexRange (direction, 0, space_dim));
// two child lines. To this end, find a pair of
// unused lines
bool pair_found=false;
+ (void)pair_found;
for (; next_unused_line!=endl; ++next_unused_line)
if (!next_unused_line->used() &&
!(++next_unused_line)->used())
template <>
double TriaAccessor<1,1,1>::extent_in_direction(const unsigned int axis) const
{
+ (void)axis;
Assert (axis == 0, ExcIndexRange (axis, 0, 1));
return this->diameter();
template <>
double TriaAccessor<1,1,2>::extent_in_direction(const unsigned int axis) const
{
+ (void)axis;
Assert (axis == 0, ExcIndexRange (axis, 0, 1));
return this->diameter();
const double length=(v1-v0).norm();
double eps=1e-12;
+ (void)eps;
double r=0;
if (compute_radius_automatically)
r = (p0 - center).norm();
void
TriaLevel<dim>::monitor_memory (const unsigned int true_dimension) const
{
+ (void)true_dimension;
Assert (2*true_dimension*refine_flags.size() == neighbors.size(),
ExcMemoryInexact (refine_flags.size(), neighbors.size()));
Assert (2*true_dimension*coarsen_flags.size() == neighbors.size(),
void
TriaLevel<3>::monitor_memory (const unsigned int true_dimension) const
{
+ (void)true_dimension;
Assert (2*true_dimension*refine_flags.size() == neighbors.size(),
ExcMemoryInexact (refine_flags.size(), neighbors.size()));
Assert (2*true_dimension*coarsen_flags.size() == neighbors.size(),
void
DoFLevel::compress_data (const dealii::hp::FECollection<dim,spacedim> &fe_collection)
{
+ (void)fe_collection;
return;
if (dof_offsets.size() == 0 || dof_indices.size()==0)
:
Subscriptor ()
{
+ (void)s;
Assert(s.rows==0, ExcInvalidConstructorCall());
Assert(s.columns==0, ExcInvalidConstructorCall());
cols(0),
rowset(0)
{
+ (void)s;
Assert (s.rows == 0, ExcInvalidConstructorCall());
Assert (s.cols == 0, ExcInvalidConstructorCall());
}
DynamicSparsityPattern &
DynamicSparsityPattern::operator = (const DynamicSparsityPattern &s)
{
+ (void)s;
Assert (s.rows == 0, ExcInvalidConstructorCall());
Assert (s.cols == 0, ExcInvalidConstructorCall());
LAPACKFullMatrix<number> &
LAPACKFullMatrix<number>::operator = (const double d)
{
+ (void)d;
Assert (d==0, ExcScalarAssignmentOnlyForZeroValue());
if (this->n_elements() != 0)
const PetscScalar *values;
int ierr;
+ (void)ierr;
ierr = MatGetRow(*matrix, this->a_row, &ncols, &colnums, &values);
AssertThrow (ierr == 0, MatrixBase::ExcPETScError(ierr));
MatrixBase &
MatrixBase::operator = (const value_type d)
{
+ (void)d;
Assert (d==value_type(), ExcScalarAssignmentOnlyForZeroValue());
assert_is_compressed ();
{
const int ierr = MatAXPY (matrix, factor,
other, DIFFERENT_NONZERO_PATTERN);
+ (void)ierr;
Assert (ierr == 0, ExcPETScError(ierr));
Assert (&src != &dst, ExcSourceEqualsDestination());
const int ierr = MatMult (matrix, src, dst);
+ (void)ierr;
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
Assert (&src != &dst, ExcSourceEqualsDestination());
const int ierr = MatMultTranspose (matrix, src, dst);
+ (void)ierr;
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
Assert (&src != &dst, ExcSourceEqualsDestination());
const int ierr = MatMultAdd (matrix, src, dst, dst);
+ (void)ierr;
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
Assert (&src != &dst, ExcSourceEqualsDestination());
const int ierr = MatMultTransposeAdd (matrix, src, dst, dst);
+ (void)ierr;
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
MatrixBase::transpose ()
{
int ierr = MatTranspose(matrix, MAT_REUSE_MATRIX, &matrix);
+ (void)ierr;
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
Vector::create_vector (const size_type n,
const size_type local_size)
{
+ (void)n;
Assert (local_size <= n, ExcIndexRange (local_size, 0, n));
ghosted = false;
const size_type local_size,
const IndexSet &ghostnodes)
{
+ (void)n;
Assert (local_size <= n, ExcIndexRange (local_size, 0, n));
ghosted = true;
ghost_indices = ghostnodes;
#if DEAL_II_PETSC_VERSION_LT(3,5,0)
int ierr;
ierr = STSetType (st, const_cast<char *>(STFOLD));
+ (void)ierr;
AssertThrow (ierr == 0, SolverBase::ExcSLEPcError(ierr));
ierr = STSetShift (st, additional_data.shift_parameter);
+ (void)ierr;
AssertThrow (ierr == 0, SolverBase::ExcSLEPcError(ierr));
#else
// PETSc/SLEPc version must be < 3.5.0.
+ (void)st;
Assert ((false),
ExcMessage ("Folding transformation has been removed in SLEPc 3.5.0 and newer."
"You cannot use this transformation anymore."));
DEAL_II_NAMESPACE_CLOSE
#endif // DEAL_II_WITH_SLEPC
-
compressed(false),
store_diagonal_first_in_row(false)
{
+ (void)s;
Assert (s.rowstart == 0, ExcInvalidConstructorCall());
Assert (s.colnums == 0, ExcInvalidConstructorCall());
Assert (s.rows == 0, ExcInvalidConstructorCall());
SparsityPattern &
SparsityPattern::operator = (const SparsityPattern &s)
{
+ (void)s;
Assert (s.rowstart == 0, ExcInvalidConstructorCall());
Assert (s.colnums == 0, ExcInvalidConstructorCall());
Assert (s.rows == 0, ExcInvalidConstructorCall());
// Make sure that METIS is actually
// installed and detected
#ifndef DEAL_II_WITH_METIS
+ (void)sparsity_pattern;
AssertThrow (false, ExcMETISNotInstalled());
#else
block_sparsity_pattern.n_block_cols()));
const size_type n_block_rows = parallel_partitioning.size();
+ (void)n_block_rows;
Assert (n_block_rows == block_sparsity_pattern.n_block_rows(),
ExcDimensionMismatch (n_block_rows,
additional_data.constant_modes[0].size() == n_rows;
const size_type n_relevant_rows =
constant_modes_are_global ? n_rows : additional_data.constant_modes[0].size();
+ (void)n_relevant_rows;
const size_type my_size = domain_map.NumMyElements();
if (constant_modes_are_global == false)
Assert (n_relevant_rows == my_size,
static_cast<size_type>(global_length(distributed_constant_modes)),
ExcDimensionMismatch(n_rows,
global_length(distributed_constant_modes)));
+ (void)global_length;
// Reshape null space as a contiguous vector of doubles so that
// Trilinos can read from it.
int *index_ptr, *rhs_index_ptr;
ierr = rhs.matrix->ExtractMyRowView (row_local, rhs_n_entries,
rhs_value_ptr, rhs_index_ptr);
+ (void)ierr;
Assert (ierr == 0, ExcTrilinosError(ierr));
ierr = matrix->ExtractMyRowView (row_local, n_entries, value_ptr,
// check whether we got the number of columns right.
AssertDimension (sparsity_pattern.n_cols(),static_cast<size_type>(
n_global_cols(*graph)));
+ (void)n_global_cols;
// And now finally generate the matrix.
matrix.reset (new Epetra_FECrsMatrix(Copy, *graph, false));
{
Epetra_Export exporter(nonlocal_graph->RowMap(), input_row_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));
// TODO Check that col_indices are int and not long long
int ierr = matrix->ExtractMyRowView(trilinos_i, nnz_extracted,
values, col_indices);
+ (void)ierr;
Assert (ierr==0, ExcTrilinosError(ierr));
Assert (nnz_present == nnz_extracted,
// an error.
int ierr = matrix->ExtractMyRowView(trilinos_i, nnz_extracted,
values, col_indices);
+ (void)ierr;
Assert (ierr==0, ExcTrilinosError(ierr));
Assert (nnz_present == nnz_extracted,
int *index_ptr, *rhs_index_ptr;
ierr = rhs.matrix->ExtractMyRowView (row_local, rhs_n_entries,
rhs_value_ptr, rhs_index_ptr);
+ (void)ierr;
Assert (ierr == 0, ExcTrilinosError(ierr));
ierr = matrix->ExtractMyRowView (row_local, n_entries, value_ptr,
*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(
static_cast<TrilinosWrappers::types::int_type>(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,
else if (fast == false)
{
const int ierr = vector->PutScalar(0.);
+ (void)ierr;
Assert (ierr == 0, ExcTrilinosError(ierr));
}
// distribution
int ierr;
ierr = vector->GlobalAssemble (last_action);
+ (void)ierr;
Assert (ierr == 0, ExcTrilinosError(ierr));
ierr = vector->PutScalar(0.0);
{
int ierr;
ierr = vector->GlobalAssemble(last_action);
+ (void)ierr;
Assert (ierr == 0, ExcTrilinosError(ierr));
ierr = vector->PutScalar(0.0);
{
int ierr;
ierr = vector->GlobalAssemble(last_action);
+ (void)ierr;
Assert (ierr == 0, ExcTrilinosError(ierr));
ierr = vector->PutScalar(0.0);
{
int ierr;
ierr = vector->GlobalAssemble(last_action);
+ (void)ierr;
Assert (ierr == 0, ExcTrilinosError(ierr));
ierr = vector->PutScalar(0.0);
// the vector, initialize our
// map with the map in v, and
// generate the vector.
+ (void)fast;
if (allow_different_maps == false)
{
if (local_range() != v.local_range())
" seems to be the same. Check vector setup!"));
ierr = vector->GlobalAssemble(last_action);
+ (void)ierr;
Assert (ierr == 0, ExcTrilinosError(ierr));
ierr = vector->PutScalar(0.0);
const int ierr = vector->Update(1.0, *v.vector, 0.0);
Assert (ierr == 0, ExcTrilinosError(ierr));
+ (void)ierr;
return *this;
}
VectorBase::print (const char *format) const
{
Assert (global_length(*vector)!=0, ExcEmptyObject());
+ (void)global_length;
for (size_type j=0; j<size(); ++j)
{
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));
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));
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
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 FiniteElement<dim> &fe = dof.get_fe();
const unsigned int n_comp = fe.n_components();
+ (void)n_comp;
Assert ((level>=1) && (level<dof.get_tria().n_global_levels()),
ExcIndexRange(level, 1, dof.get_tria().n_global_levels()));
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
= *std::max_element (target_block.begin(),
target_block.end());
const unsigned int n_target_blocks = max_block + 1;
+ (void)n_target_blocks;
for (unsigned int l=0; l<n_levels; ++l)
AssertDimension (dofs_per_block[l].size(), n_target_blocks);
const unsigned int n_levels = dof.get_tria().n_global_levels();
+ (void)n_levels;
const unsigned int n_components = DoFTools::n_components(dof);
{
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);
}
dealii::hp::FEFaceValues<DH::dimension, DH::space_dimension> &fe_face_values_neighbor)
{
const unsigned int dim = DH::dimension;
+ (void)dim;
const typename DH::face_iterator face = cell->face(face_no);
const unsigned int n_solution_vectors = solutions.size();
dealii::hp::FESubfaceValues<DH::dimension, DH::space_dimension> &fe_subface_values)
{
const unsigned int dim = DH::dimension;
+ (void)dim;
const typename DH::cell_iterator neighbor = cell->neighbor(face_no);
+ (void)neighbor;
const unsigned int n_solution_vectors = solutions.size();
const typename DH::face_iterator
face=cell->face(face_no);
#endif
const unsigned int n_components = dof_handler.get_fe().n_components();
+ (void)n_components;
// sanity checks
Assert (solutions.size() > 0,
VectorType *right_hand_side)
{
const unsigned int dofs_per_cell = data.dof_indices.size();
+ (void)dofs_per_cell;
Assert (data.cell_matrix.m() == dofs_per_cell,
ExcInternalError());
for (; dof != endd; ++dof)
{
Assert (dof->first < n_dofs, ExcInternalError());
+ (void)n_dofs;
// get global index and index
// in the block in which this
PETScVector &right_hand_side,
const bool eliminate_columns)
{
+ (void)eliminate_columns;
Assert (eliminate_columns == false, ExcNotImplemented());
Assert (matrix.n() == right_hand_side.size(),
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()));
typename std::map <std::string, ComponentMask>::iterator mask = 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));
names->second = component_names;
clear();
const unsigned int n_active_cells = dof_handler->get_tria().n_active_cells();
+ (void)n_active_cells;
n_dofs_old = dof_handler->n_dofs();
for (unsigned int i=0; i<in_size; ++i)
project_to_manifold (const std::vector<Point<spacedim> > &surrounding_points,
const Point<spacedim> &candidate) const
{
+ (void)surrounding_points;
#ifdef DEBUG
for (unsigned int i=0; i<surrounding_points.size(); ++i)
Assert(closest_point(sh, surrounding_points[i], tolerance)
project_to_manifold (const std::vector<Point<spacedim> > &surrounding_points,
const Point<spacedim> &candidate) const
{
+ (void)surrounding_points;
#ifdef DEBUG
for (unsigned int i=0; i<surrounding_points.size(); ++i)
Assert(closest_point(sh, surrounding_points[i],tolerance)
// something is wrong
std_cxx11::tuple<unsigned int, unsigned int, unsigned int> numbers =
count_elements(out_shape);
+ (void)numbers;
Assert(std_cxx11::get<0>(numbers) > 0,
ExcMessage("Could not find normal: the shape containing the closest point has 0 faces."));