inline RefinementCase<dim>
RefinementCase<dim>::cut_axis(const unsigned int)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return static_cast<std::uint8_t>(-1);
}
point -= unit_cell_vertex(child_index);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return point;
point -= unit_cell_vertex(child_index);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return point;
point *= 0.5;
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return point;
point *= 0.5;
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return point;
default:
// there should be no
// cases left
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
default:
// there should be no
// cases left
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
}
// The function should not reach this point
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {};
}
previous_indices[2],
new_index};
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {};
}
}
return dim + c;
// should never get here:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return 0;
}
}
return {d, e};
// should never get here:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {0, 0};
}
}
case Storage::column_major:
return linear_index % container->n_rows();
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return {};
}
case Storage::column_major:
return linear_index / container->n_rows();
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return {};
}
ar &c &p;
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
} // namespace internal
// somehow? that
// shouldn't have
// happened
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
std::vector<char> &)
{
// We shouldn't get here:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
T &)
{
// We shouldn't get here:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
else
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
else if constexpr (decltype(has_cells(cgal_triangulation)){})
}
else
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
dealii_triangulation.create_triangulation(vertices, cells, subcell_data);
}
else
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
}
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
}
process_object_range(dealii::DoFInvalidAccessor<structdim, dim, spacedim>,
const unsigned int)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {0, 0};
}
vertex_index,
fe_index,
[](const auto d) {
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return d;
},
std::integral_constant<int, 0>(),
default:
// shouldn't get here
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return neither_element_dominates;
case 3:
return n_dofs_per_hex();
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return numbers::invalid_unsigned_int;
}
}
}
// should not end up here
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return curl_type();
}
}
// bogus return to placate compiler. It should not be possible to get
// here.
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::quiet_NaN()};
}
const Point<spacedim> & /*p*/)
{
// It should not be possible to get here
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::quiet_NaN()};
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
return points_weights;
case 2:
return xi[std::min(1, dim - 1)];
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
// see also BarycentricPolynomials<3>::compute_value
case 3:
return xi[std::min(2, dim - 1)];
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
// see also ScalarLagrangePolynomialPyramid::compute_value()
case 2:
return Point<dim>(+0.0, +1.0);
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
default:
DEAL_II_NOT_IMPLEMENTED();
else if (face_reference_cell(face_no) == ReferenceCells::Triangle)
return 6;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return numbers::invalid_unsigned_int;
}
void
operator++() const
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
void
operator--() const
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
};
};
if (structdim == 2 && dim > 2)
return this->tria->faces->quads;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return this->tria->levels[this->present_level]->cells;
}
const unsigned int,
const unsigned char)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
const unsigned int,
const bool)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
{
// quads in 2d have no
// non-standard orientation
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
static std::array<unsigned int, 1>
get_line_indices_of_cell(const TriaAccessor<1, dim, spacedim> &)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {};
}
static std::array<unsigned char, 1>
get_line_orientations_of_cell(const TriaAccessor<1, dim, spacedim> &)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {};
}
// We cannot convert from TriaAccessorBase to
// TriaAccessor<0,1,spacedim> because the latter is not derived from
// the former. We should never get here.
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
case RefinementCase<3>::cut_xy:
return dealii::internal::SubfaceCase<3>::case_xy;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
// we should never get here
return dealii::internal::SubfaceCase<3>::case_none;
block_columns += sub_objects[row_index.first][b]->n_cols();
}
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return 0;
}
}};
#else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
#endif
}
}
{
// dummy implementation. this function is not needed for the present
// implementation of gmres
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return 0;
}
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
if (j == i + 1)
return right[i];
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return 0;
}
if (j == i + 1)
return right[i];
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return diagonal[0];
}
const LinearAlgebra::CUDAWrappers::Vector<Number> &,
LinearAlgebra::CUDAWrappers::Vector<Number> &) const
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
#endif
} // namespace CUDAWrappers
// This should never happen since the FE_RaviartThomasNodal is not
// defined for dim = 1. It prevents compiler warnings of infinite
// recursion.
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return;
}
{
// We should not end up here, this should be caught by
// FEFaceEvaluationImplGatherEvaluateSelector::supports()
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
temp1 += 3 * dofs_per_face;
}
{
(void)kind;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return v > 0; // should not be called
}
else if (dim == 2)
gradient[0] = interpolated_value[0];
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
else if (this->current_face_number / 2 == 2)
{
gradient[2] = interpolated_value[dim];
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
else
{
else if (dim == 2)
gradient_in_face[0] = gradient[0];
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
else if (this->current_face_number / 2 == 2)
{
gradient_in_face[1] = gradient[1];
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
internal::integrate_tensor_product_value_and_gradient<
is_linear,
const Point<0, Number> &,
const unsigned int)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
ps->get_quadrature(),
ps->get_update_flags());
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
#endif
{
return FineDoFHandlerViewCell(
[]() {
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return false;
},
[this, cell](auto &dof_indices) {
get_cell_view(const typename DoFHandler<dim>::cell_iterator &,
const unsigned int) const override
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return FineDoFHandlerViewCell(
[]() {
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return false;
},
- [](auto &) { Assert(false, ExcInternalError()); },
+ [](auto &) { DEAL_II_ASSERT_UNREACHABLE(); },
[]() {
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return 0;
});
}
{
return FineDoFHandlerViewCell(
[]() {
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return false;
},
[this, cell, c](auto &dof_indices) {
return value.imag();
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return numbers::signaling_nan<double>();
else if (actual_type == DataVectorType::type_cell_data)
create_cell_vector(*data, vector);
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
deduced_names.size(), dof_handler->get_fe(0).n_components()));
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
const auto &data_component_interpretation =
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
}
{
// dummy implementation of above function
// for all other dimensions
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
if (type == NOX::Abstract::Vector::NormType::MaxNorm)
return vector->linfty_norm();
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return 0.0;
}
set_node_numbers(const unsigned int /*start*/,
const std::array<unsigned int, 0> & /*d1*/)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {};
}
else
// we shouldn't get here, since the parameter object should already have
// checked that the given value is valid
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
}
// There aren't any other reference cells in 2d than the
// quadrilateral and the triangle. So whatever we got here
// can't be any good
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
// end of patch
out << '\n';
default:
// VTK doesn't support anything else than vectors with 1, 2,
// or 3 components
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
}
default:
// Anything else is not yet implemented
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
else
}
else
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
// now put the tensor into data
return std::string("H5D_MPIO_CONTIGUOUS_COLLECTIVE");
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return std::string("Internal error");
break;
}
// The function should not reach this line.
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return std::string("Internal error");
}
Assert(*hdf5_reference >= 0, ExcMessage("Error at H5Gcreate2"));
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
}
Assert(*hdf5_reference >= 0, ExcMessage("Error at H5Fcreate"));
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
(own_it->end - own_it->begin));
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
// We considered the overlap of these two intervals. It may of course
// be that one of them overlaps with another one, but that can only
c = 15 * 16;
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
switch (s[i + 2])
{
c += 15;
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
u.push_back(static_cast<char>(c));
break;
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
Assert(x != nullptr, ExcInternalError());
else
k += n_1d - iy;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {{numbers::invalid_unsigned_int, numbers::invalid_unsigned_int}};
}
else
k += n_1d - iy - iz;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {{numbers::invalid_unsigned_int, numbers::invalid_unsigned_int}};
}
eta_translation = int(subface_no / 2) * 0.5;
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
case 7:
return rotate(reflect(points), 8 - offset);
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return {};
}
q_points[p] = Point<dim>(0, 1 - quadrature.point(p)[0]);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
else if (reference_cell == ReferenceCells::Quadrilateral)
q_points[p] = Point<dim>(quadrature.point(p)[0], 1);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
else
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
Point<dim>(0.5 + quadrature.point(p)[0] / 2, 0);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
case 1:
0.5 + quadrature.point(p)[0] / 2);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
case 2:
Point<dim>(0, 0.5 - quadrature.point(p)[0] / 2);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
else if (reference_cell == ReferenceCells::Quadrilateral)
Point<dim>(0, quadrature.point(p)[0] / 2 + 0.5);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
case 1:
Point<dim>(1, quadrature.point(p)[0] / 2 + 0.5);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
case 2:
Point<dim>(quadrature.point(p)[0] / 2 + 0.5, 0);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
case 3:
Point<dim>(quadrature.point(p)[0] / 2 + 0.5, 1);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
else
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return numbers::invalid_unsigned_int;
}
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return numbers::invalid_unsigned_int;
}
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
case 3:
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
case 4:
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
case 5:
Quadrature<dim>
setup_qiterated_1D(const Quadrature<dim> &, const unsigned int)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return Quadrature<dim>();
}
tex_supercaptions.insert(new_tex_supercaption);
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
deal2cgal.at(face->vertex_index(2))};
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
if (clockwise_ordering == true)
std::reverse(indices.begin(), indices.end());
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
}
while (true);
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return -1;
}
} // namespace RefineAndCoarsenFixedNumber
}
while (true);
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return -1;
}
} // namespace RefineAndCoarsenFixedFraction
{
// the underlying triangulation should not be checking for distorted
// cells
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
partition();
this->update_number_cache();
{
(void)construction_data;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
}
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
}
{
// the underlying triangulation should not be checking for distorted
// cells
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
Assert(
{
// the underlying triangulation should not be checking for distorted
// cells
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
this->update_periodic_face_map();
{
(void)construction_data;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
{
// the underlying triangulation should not be checking for distorted
// cells
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
// Load attached cell data, if any was stored.
{
// the underlying triangulation should not be checking for distorted
// cells
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
this->update_periodic_face_map();
{
// the underlying triangulation should not be checking for
// distorted cells
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
{
// the underlying triangulation should not be checking for
// distorted cells
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
while (mesh_changed);
{
// the underlying triangulation should not be checking for distorted
// cells
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
// transfer data after triangulation got updated
{
// the underlying triangulation should not be checking for distorted
// cells
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
// transfer data after triangulation got updated
{
// the underlying triangulation should not be checking for distorted
// cells
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
// The range of ghost_owners might have changed so update that
{
// the underlying triangulation should not be checking for distorted
// cells
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
if (const dealii::parallel::distributed::Triangulation<dim, spacedim>
{
// the underlying triangulation should not be checking for distorted
// cells
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
this->update_periodic_face_map();
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
}
const unsigned int,
const types::fe_index) const
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return 0;
}
const types::global_dof_index,
const types::fe_index) const
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
void DoFHandler<dim, spacedim>::post_distributed_transfer_action()
{
# ifndef DEAL_II_WITH_P4EST
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
# else
update_active_fe_table();
}
#else
(void)tria;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
#endif
}
else
}
#else
(void)tria;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
#endif
}
else
default:
// we shouldn't get here
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
else
default:
// we shouldn't get here
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
}
cell_extent = data->cell_extents[0];
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
const unsigned int regularity = fe_herm.get_regularity();
const unsigned int n_dofs_per_cell = fe_herm.n_dofs_per_cell();
cell_extents = data->cell_extents;
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
const unsigned int regularity = fe_herm.get_regularity();
const unsigned int n_dofs_per_cell = fe_herm.n_dofs_per_cell();
cell_extents = data->cell_extents;
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
const unsigned int regularity = fe_herm.get_regularity();
const unsigned int n_dofs_per_cell = fe_herm.n_dofs_per_cell();
switch (dim)
{
case 1:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
case 2:
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return (this->get_first_line_index() +
}
// we should not have gotten here
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return false;
}
q_fine = std::make_unique<QGauss<dim>>(degree + 1);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
Assert(q_fine.get() != nullptr, ExcInternalError());
}
// we should not have gotten here
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return false;
}
if (this->system_to_base_index(i) == target)
return i;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return numbers::invalid_unsigned_int;
}
{
// we should never get here! (in 1d, the constraints matrix
// should be of size zero)
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
subface_index = cell->face(face_no)->child_index(1);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
case internal::SubfaceCase<3>::case_x2y:
cell->face(face_no)->child(1)->child_index(subface_no - 1);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
Assert(subface_index != numbers::invalid_unsigned_int,
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
for (const auto &p : fe_quad.get_unit_support_points())
this->unit_face_support_points[f].emplace_back(p[0], p[1]);
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
// We should never get here
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {};
}
const Point<dim> &) const
{
// default implementation (should never be called)
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {};
}
default:
{
// we should get here, based on the if-condition at the top
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
}
const typename Triangulation<dim, spacedim>::cell_iterator &,
std::vector<Point<spacedim>> &) const
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
// is on the boundary,
// but we could not find
// on which boundary.
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
for (const auto &cell : tria.cell_iterators())
cell->face(f)->line(j)->set_boundary_id(1);
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
break;
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
(void)twisted_data; // make the static analyzer happy
Assert(
new_points[v][2] = -tria_copy.get_vertices()[v][2];
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
// the cell data is exactly the same as before
break;
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
out_tria.create_triangulation(v, cells, subcelldata);
cells[i].manifold_id =
static_cast<types::manifold_id>(id);
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
if (dim == 3)
boundary_quad.manifold_id =
static_cast<types::manifold_id>(id);
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
for (auto &boundary_line : subcelldata.boundary_lines)
{
boundary_line.manifold_id =
static_cast<types::manifold_id>(id);
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
else if (dim == 2)
boundary_line.manifold_id =
static_cast<types::manifold_id>(id);
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
}
cells.back().vertices = vertices_for_this_element;
}
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
else
DEAL_II_NOT_IMPLEMENTED();
cells[cells.size() - n_elements + e].material_id =
geometric_entity_index;
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
else
DEAL_II_NOT_IMPLEMENTED();
case Default:
break;
}
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
out << cell->level_subdomain_id() + 32;
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
// Depth, unused, fill
(face->reference_cell() == ReferenceCells::Line))
out << ' ' << face->vertex_index(vertex) + 1;
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
out << '\n';
{
case 1:
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
return;
}
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
else
{
// We should not get here. Throw an error.
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
// Now make sure we send out the rest of the points that we did not find.
starting_vertex_of_edge[3]))
origin_vertex_of_cell = starting_vertex_of_edge[1];
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
case 0:
case 1:
case 2:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
case 3:
return chart_points[1] + (chart_points[2] - chart_points[0]);
case 7:
return 0.5 * (chart_points[2] + chart_points[3]);
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return {};
// a valid inversion should have returned a point above. an invalid
// inversion should have triggered the assertion, so we should never end up
// here
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return typename Triangulation<dim, spacedim>::cell_iterator();
}
{
(void)construction_data;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
const Point<dim> & /*p*/,
const ReferenceCell /*reference_cell*/)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return std::make_pair(Point<dim>(),
std::numeric_limits<double>::signaling_NaN());
}
switch (this->kind)
{
case ReferenceCells::Vertex:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
// the bounds for each dimension of a hypercube are mutually
// independent:
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
default:
// only remaining case is
// no_refinement, thus an error
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
}
}
else
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
// Also check whether we have to refine any of the faces and
}
else
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
else
{
// we should never get here
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
// mark all faces for refinement; checking locally
n_new_hexes = 8;
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
// untreated enumeration value. However, in that
// case we should have aborted much
// earlier. thus we should never get here
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
} // switch (ref_case)
bool
get_user_flag(const TriaIterator<InvalidAccessor<structdim, dim, spacedim>> &)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return false;
}
void
set_user_flag(const TriaIterator<InvalidAccessor<structdim, dim, spacedim>> &)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
clear_user_flag(
const TriaIterator<InvalidAccessor<structdim, dim, spacedim>> &)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
} // namespace
get_user_index(
const TriaIterator<InvalidAccessor<structdim, dim, spacedim>> &)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return numbers::invalid_unsigned_int;
}
const TriaIterator<InvalidAccessor<structdim, dim, spacedim>> &,
const unsigned int)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
} // namespace
get_user_pointer(
const TriaIterator<InvalidAccessor<structdim, dim, spacedim>> &)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return nullptr;
}
const TriaIterator<InvalidAccessor<structdim, dim, spacedim>> &,
void *)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
} // namespace
}
else
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {};
}
}
Assert(accessor.reference_cell() != ReferenceCells::Pyramid &&
accessor.reference_cell() != ReferenceCells::Wedge,
ExcNotImplemented());
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return {};
}
// we should never get here,
// since then we did not find
// our way back...
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return std::make_pair(numbers::invalid_unsigned_int,
numbers::invalid_unsigned_int);
}
// we should never get here, since then we did not find our way
// back...
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return std::make_pair(numbers::invalid_unsigned_int,
numbers::invalid_unsigned_int);
}
requested = mother_face->child(1);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
case internal::SubfaceCase<3>::case_x2y:
requested = mother_face->child(1)->child(subface - 1);
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
Assert(requested == neighbor_child->face(neighbor_neighbor),
&dof_handler.get_triangulation()) == nullptr)
{
#ifndef DEAL_II_WITH_P4EST
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
#else
//
// parallel implementation with distributed memory
{
// Siblings of locally owned cells are all
// either also locally owned or ghost cells.
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
}
# ifndef DEAL_II_WITH_HDF5
(void)filename;
(void)chunk_size;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
# else
/*
# ifndef DEAL_II_WITH_HDF5
(void)filename;
(void)chunk_size;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
# else
const unsigned int n_mpi_processes(
{
# ifndef DEAL_II_WITH_HDF5
(void)filename;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
# else
/*
{
# ifndef DEAL_II_WITH_HDF5
(void)filename;
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
# else
# ifndef H5_HAVE_PARALLEL
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
# else
const unsigned int n_mpi_processes(
}
default:
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
}
}
default:
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
}
// we have either return or Assert
// statements above, so shouldn't
// get here!
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
// move right bound arbitrarily if
}
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
// fill the other lists of intervals
}
// undefined status
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
}
return changed_grid;
}
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return false;
}
, wakeup_level_to_build_grid(0)
, sleep_level_to_delete_grid(0)
{
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
}
return Handle(BRepAdaptor_Curve)(
new BRepAdaptor_Curve(TopoDS::Edge(shape)));
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return Handle(BRepAdaptor_Curve)(new BRepAdaptor_Curve());
}
# else
return Handle(BRepAdaptor_HCurve)(
new BRepAdaptor_HCurve(TopoDS::Edge(shape)));
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
return Handle(BRepAdaptor_HCurve)(new BRepAdaptor_HCurve());
}
# endif
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
break;
default:
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
break;
}
}
else if (value == "picard")
strategy = picard;
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
});
prm.add_parameter("Maximum number of nonlinear iterations",
maximum_non_linear_iterations);
anderson_qr_orthogonalization =
delayed_classical_gram_schmidt;
else
- Assert(false, ExcInternalError());
+ DEAL_II_ASSERT_UNREACHABLE();
});
prm.leave_subsection();
}
projects / dealii.git / commitdiff