case 3:
return "x,y,z";
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return "";
}
inline Point<dim>
GeometryInfo<dim>::unit_cell_vertex(const unsigned int)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
inline unsigned int
GeometryInfo<dim>::child_cell_from_point(const Point<dim> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
const RefinementCase<dim> /*refine_case*/)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
const unsigned int /*child_index*/,
const RefinementCase<dim> /*refine_case*/)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
inline bool
GeometryInfo<dim>::is_inside_unit_cell(const Point<dim> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return false;
}
inline bool
GeometryInfo<dim>::is_inside_unit_cell(const Point<dim> &, const double)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return false;
}
inline unsigned int
GeometryInfo<4>::line_to_cell_vertices(const unsigned int, const unsigned int)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return numbers::invalid_unsigned_int;
}
inline unsigned int
GeometryInfo<dim>::n_subfaces(const internal::SubfaceCase<dim> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
GeometryInfo<dim>::subface_ratio(const internal::SubfaceCase<dim> &,
const unsigned int)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0.;
}
const bool,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return RefinementCase<dim - 1>::no_refinement;
}
GeometryInfo<dim>::line_refinement_case(const RefinementCase<dim> &,
const unsigned int)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return RefinementCase<1>::no_refinement;
}
const bool,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return RefinementCase<dim>::no_refinement;
}
GeometryInfo<dim>::min_cell_refinement_case_for_line_refinement(
const unsigned int)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return RefinementCase<dim>::no_refinement;
}
const bool,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return line;
}
GeometryInfo<dim>::standard_to_real_line_vertex(const unsigned int vertex,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return vertex;
}
GeometryInfo<dim>::standard_quad_vertex_to_line_vertex_index(
const unsigned int vertex)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
(void)vertex;
return {{0, 0}};
}
inline std::array<unsigned int, 2>
GeometryInfo<dim>::standard_hex_line_to_quad_line_index(const unsigned int line)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
(void)line;
return {{0, 0}};
}
GeometryInfo<dim>::standard_hex_vertex_to_quad_vertex_index(
const unsigned int vertex)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
(void)vertex;
return {{0, 0}};
}
const bool,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return line;
}
const bool,
const RefinementCase<3> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return numbers::invalid_unsigned_int;
}
const bool,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return numbers::invalid_unsigned_int;
}
const bool,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return numbers::invalid_unsigned_int;
}
const bool,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return numbers::invalid_unsigned_int;
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return -1e9;
}
GeometryInfo<dim>::d_linear_shape_function_gradient(const Point<dim> &,
const unsigned int)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return Tensor<1, dim>();
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return derivative;
}
}
PolynomialsAdini<dim>::compute_1st_derivative(const unsigned int /*i*/,
const Point<dim> & /*p*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
PolynomialsAdini<dim>::compute_2nd_derivative(const unsigned int /*i*/,
const Point<dim> & /*p*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
PolynomialsAdini<dim>::compute_3rd_derivative(const unsigned int /*i*/,
const Point<dim> & /*p*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
PolynomialsAdini<dim>::compute_4th_derivative(const unsigned int /*i*/,
const Point<dim> & /*p*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return derivative;
}
auto derivative = compute_4th_derivative(i, p);
return *reinterpret_cast<Tensor<order, dim> *>(&derivative);
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
Tensor<order, dim> empty;
return empty;
}
component_to_unrolled_index(const TableIndices<rank_> &indices)
{
(void)indices;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return numbers::invalid_unsigned_int;
}
} // namespace SymmetricTensorImplementation
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// The code should never reach here.
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// The code should never reach here.
0,
dealii::SymmetricTensor<rank_, dim, double>::
n_independent_components));
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return TableIndices<rank_>();
}
t.data[2] * t.data[3] * t.data[3]);
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return internal::NumberType<Number>::value(0.0);
}
}
void
fill_Fortran_style(InputIterator, TableBase<N, T> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
} // namespace TableImplementation
} // namespace internal
case 3:
return "x,y,z";
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return "";
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return derivative;
}
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return derivative;
}
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return derivative;
}
}
const types::global_dof_index /*index*/,
const types::fe_index /*fe_index*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
DoFAccessor<0, 1, spacedim, level_dof_access>::fe_index_is_active(
const types::fe_index /*fe_index*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return false;
}
DoFAccessor<0, 1, spacedim, level_dof_access>::line(
const unsigned int /*c*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return typename dealii::internal::DoFHandlerImplementation::
Iterators<1, spacedim, level_dof_access>::line_iterator();
}
DoFAccessor<0, 1, spacedim, level_dof_access>::quad(
const unsigned int /*c*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return typename dealii::internal::DoFHandlerImplementation::
Iterators<1, spacedim, level_dof_access>::quad_iterator();
}
std::size_t
FE_DGVector<PolynomialType, dim, spacedim>::memory_consumption() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
if (data_ptr->update_each & update_gradients ||
data_ptr->update_each & update_hessians)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return data_ptr;
if (space_tensor_prod_const != nullptr)
return space_tensor_prod_const->get_numbering();
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<unsigned int>();
}
if (data.update_each & update_gradients ||
data.update_each & update_hessians)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return data_ptr;
std::unique_ptr<FiniteElement<FE::dimension, FE::space_dimension>>
FEFactory<FE>::get(const Quadrature<1> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return nullptr;
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return h2l;
public:
ExtrapolateImplementation()
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
template <class InVector>
const DoFHandler<dim, spacedim> & /*dof2*/,
OutVector & /*u2*/)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
};
void
reinit_ghosted(const DH & /*dh*/, VectorType & /*vector*/)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
#ifdef DEAL_II_WITH_PETSC
const AffineConstraints<PETScWrappers::MPI::BlockVector::value_type> &,
PETScWrappers::MPI::BlockVector &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
#endif
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
divergence_type return_value;
return return_value;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
divergence_type return_value;
return return_value;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
gradient_type return_value;
return return_value;
}
cross_product_3d(data.aux[0][i], data.aux[1][i]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else //(dim < spacedim)
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
return;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
} // namespace MappingQImplementation
virtual unsigned int
n_entities(const unsigned int d) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
(void)d;
return 0;
virtual dealii::ArrayView<const unsigned int>
vertices_of_entity(const unsigned int d, const unsigned int e) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
(void)d;
(void)e;
virtual ReferenceCell
type_of_entity(const unsigned int d, const unsigned int e) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
(void)d;
(void)e;
virtual unsigned int
n_lines_of_surface(const unsigned int face) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
(void)face;
return 0;
nth_line_of_surface(const unsigned int line,
const unsigned int face) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
(void)line;
(void)face;
vertices_of_nth_line_of_surface(const unsigned int line,
const unsigned int face) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
(void)line;
(void)face;
return {table};
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
if (d == 1)
return ReferenceCells::Line;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return ReferenceCells::Vertex;
}
return {table[e]};
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
if (d == 1)
return ReferenceCells::Line;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return ReferenceCells::Vertex;
}
return {table[e]};
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
if (d == 1)
return ReferenceCells::Line;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return ReferenceCells::Vertex;
}
return {table[e]};
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
if (d == 1)
return ReferenceCells::Line;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return ReferenceCells::Vertex;
}
return {table[e]};
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
if (d == 1)
return ReferenceCells::Line;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return ReferenceCells::Vertex;
}
return {table[e]};
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
if (d == 1)
return ReferenceCells::Line;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return ReferenceCells::Vertex;
}
return {table[e]};
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
if (d == 1)
return ReferenceCells::Line;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return ReferenceCells::Vertex;
}
else if (from == 1 && to == 0)
return line_vertices;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return cell_entities;
}
else if (from == 1 && to == 0)
return line_vertices;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return cell_entities;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return projected_point;
}
case ReferenceCells::Hexahedron:
return {&GeometryInfo<3>::vertex_to_face[vertex][0], 3};
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return {};
case ReferenceCells::Hexahedron:
return 3;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
case ReferenceCells::Hexahedron:
return 8;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
case ReferenceCells::Hexahedron:
return 12;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return Point<dim>();
}
case ReferenceCells::Hexahedron:
return 6;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
case ReferenceCells::Pyramid:
// We haven't yet decided how to refine pyramids. Update this when we
// have
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return numbers::invalid_unsigned_int;
case ReferenceCells::Wedge:
return 8;
case ReferenceCells::Hexahedron:
return 8;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
case ReferenceCells::Hexahedron:
return ReferenceCells::Quadrilateral;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return ReferenceCells::Invalid;
case ReferenceCells::Vertex:
case ReferenceCells::Line:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
case ReferenceCells::Triangle:
case ReferenceCells::Pyramid:
case ReferenceCells::Wedge:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
case ReferenceCells::Hexahedron:
face_rotation);
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
{
case ReferenceCells::Vertex:
case ReferenceCells::Line:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
case ReferenceCells::Triangle:
{
vertex);
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return {};
case ReferenceCells::Triangle:
case ReferenceCells::Quadrilateral:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
case ReferenceCells::Tetrahedron:
return GeometryInfo<3>::standard_hex_line_to_quad_line_index(line);
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return {};
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
{
case ReferenceCells::Vertex:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
case ReferenceCells::Line:
face, line, face_orientation, face_flip, face_rotation);
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
{
case ReferenceCells::Vertex:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
case ReferenceCells::Line:
face, vertex, face_orientation, face_flip, face_rotation);
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
{
case ReferenceCells::Vertex:
case ReferenceCells::Line:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
case ReferenceCells::Triangle:
case ReferenceCells::Quadrilateral:
case ReferenceCells::Hexahedron:
return quadrilateral_vertex_permutations[face_orientation][vertex];
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return numbers::invalid_unsigned_int;
}
case ReferenceCells::Line:
case ReferenceCells::Triangle:
case ReferenceCells::Quadrilateral:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
case ReferenceCells::Tetrahedron:
return triangle_table[combined_face_orientation][line];
return table[combined_face_orientation][line];
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
case 3:
return ReferenceCells::Tetrahedron;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return ReferenceCells::Invalid;
}
case 3:
return ReferenceCells::Hexahedron;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return ReferenceCells::Invalid;
}
.d_linear_shape_function<1>(Point<1>(xi[std::min(2, dim - 1)]),
i / 3);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0.0;
Assert(false, ExcInternalError());
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return Point<dim>(+0.0, +0.0, +0.0);
case ReferenceCells::Hexahedron:
return 1;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0.0;
case ReferenceCells::Hexahedron:
return Point<dim>(1. / 2., 1. / 2., 1. / 2.);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return Point<dim>();
return true;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return false;
return table[face_no][i];
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
unit_tangential_vectors<dim>(face_no, 1));
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
return 6;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(false, (internal::NoPermutation<T>(*this, vertices_0, vertices_1)));
case 0:
return {vertices[1], vertices[0]};
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
break;
case ReferenceCells::Triangle:
case 4:
return {vertices[1], vertices[0], vertices[2]};
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
break;
case ReferenceCells::Quadrilateral:
case 6:
return {vertices[1], vertices[0], vertices[3], vertices[2]};
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
break;
default:
(vertices[2] - vertices[5]).norm(),
(vertices[3] - vertices[4]).norm()});
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return -1e10;
}
} // namespace TriaAccessorImplementation
{
// it seems like we don't need this
// one
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
case 3:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return -1;
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// we don't get here but have to return
// something...
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
this->line(i)->set_manifold_id(manifold_ind);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::pair<Point<spacedim>, double>();
}
return std::sqrt(min);
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return -1e10;
}
}
inline void
TriaAccessor<0, 1, spacedim>::operator++() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
inline void
TriaAccessor<0, 1, spacedim>::operator--() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
result[2] = h0[2][0] + h1[2][1] - h2[0][0] - h2[1][1];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return result;
}
normal[1] * (g1[0] - g2[1]) + normal[0] * (g0[2] - g2[0]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return result;
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
}
// TODO: implement this
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
number3 *,
dealii::types::blas_int)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(cols != nullptr, ExcNeedsSparsityPattern());
Assert(cols->rows == cols->cols, ExcNotQuadratic());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(dst.size() == n(), ExcDimensionMismatch(dst.size(), n()));
Assert(src.size() == n(), ExcDimensionMismatch(src.size(), n()));
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(dst.size() == n(), ExcDimensionMismatch(dst.size(), n()));
Assert(src.size() == n(), ExcDimensionMismatch(src.size(), n()));
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
ExcMessage("This operation is only valid on square matrices."));
Assert(m() == dst.size(), ExcDimensionMismatch(m(), dst.size()));
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
ExcMessage("This operation is only valid on square matrices."));
Assert(m() == dst.size(), ExcDimensionMismatch(m(), dst.size()));
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(m() == inverse_permutation.size(),
ExcDimensionMismatch(m(), inverse_permutation.size()));
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(m() == inverse_permutation.size(),
ExcDimensionMismatch(m(), inverse_permutation.size()));
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(m() == v.size(), ExcDimensionMismatch(m(), v.size()));
Assert(m() == b.size(), ExcDimensionMismatch(m(), b.size()));
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(m() == v.size(), ExcDimensionMismatch(m(), v.size()));
Assert(m() == b.size(), ExcDimensionMismatch(m(), b.size()));
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(m() == dst.size(), ExcDimensionMismatch(m(), dst.size()));
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(cols != nullptr, ExcNeedsSparsityPattern());
Assert(val != nullptr, ExcNotInitialized());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
AssertThrow(out.fail() == false, ExcIO());
}
unsigned int width = width_;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
std::ios::fmtflags old_flags = out.flags();
unsigned int old_precision = out.precision(precision);
(void)other;
Assert(accessor.sparsity_pattern == other.accessor.sparsity_pattern,
ExcInternalError());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
void
Householder<number>::Tvmult(VectorType &, const VectorType &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return "Hessenberg";
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return "invalid";
}
number3 *,
const dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
number5 *,
const dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
number5 *,
const dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
inline number1
lamch(const char *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return number1();
}
const dealii::types::blas_int *,
number2 *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return number1();
}
const dealii::types::blas_int *,
number2 *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return number1();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
number4 *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
number3 *,
const dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
number4 *,
const dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
number2 *,
const dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const dealii::types::blas_int *,
dealii::types::blas_int *)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
{
if (really_clean)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else
{
{
if (really_clean)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else
{
data.eig_cg_n_iterations));
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
// read the eigenvalues from the attached eigenvalue tracker
if (eigenvalue_tracker.values.empty())
this->inverse_svd(0).compute_inverse_svd(0.);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else
this->inverse_svd(cell).compute_inverse_svd(0.);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
this->inverse_svd(0).compute_inverse_svd(1.e-12);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else
this->inverse_svd(cell).compute_inverse_svd(1.e-12);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
var_inverse_svd[0].reinit(b, b);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
if (store_diagonals())
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
var_inverse_svd[ii].vmult(dst, src);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
var_inverse_svd[ii].Tvmult(dst, src);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
A->precondition_SSOR(dst, src, omega);
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
A->precondition_SSOR(dst, src, omega); // Symmetric operation
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
{
if (this->same_diagonal())
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else
{
this->additional_data->threshold);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
{
// TODO: Is this called anywhere? If so, multiplication with omega(2-omega)D
// is missing
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
Assert(cols != nullptr, ExcNeedsSparsityPattern());
Assert(val != nullptr, ExcNotInitialized());
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Teuchos::SerialDenseMatrix<int, value_type> &,
const bool = false)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
virtual int
Teuchos::SerialDenseMatrix<int, value_type> &,
const typename Teuchos::ScalarTraits<value_type>::magnitudeType &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
# endif
else if (operation == VectorOperation::add)
tpetra_operation = Tpetra::ADD;
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
vector->doExport(source_vector, *tpetra_export, tpetra_operation);
}
else if (operation == VectorOperation::add)
tpetra_operation = Tpetra::ADD;
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
Teuchos::RCP<const ExportType> exporter =
Tpetra::createExport(nonlocal_vector->getMap(), vector->getMap());
values_quad[0] = values_dofs[0];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// Note: we always keep storage of values, 1st and 2nd derivatives
// in an array
values_dofs[0] = values_quad[0];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
values_dofs += 3 * n_dofs;
values_quad += n_q_points;
// TODO: This is currently not implemented, but the test
// matrix_vector_rt_face_03 apparently works without it -> check
// if (subface_index < GeometryInfo<dim - 1>::max_children_per_cell)
- // Assert(false, ExcNotImplemented());
+ // DEAL_II_NOT_IMPLEMENTED();
using Eval = EvaluatorTensorProduct<evaluate_evenodd,
dim - 1,
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else if (n_face_orientations == n_lanes)
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
};
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
(jac[1][1] * jac[2][2]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
for (unsigned int d = 0; d < dim; ++d)
for (unsigned int e = d + 1; e < dim; ++e)
symmetrized[5] *= half;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return SymmetricTensor<2, dim, VectorizedArrayType>(symmetrized);
}
curl[2] = grad[1][0] - grad[0][1];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return curl;
}
grad[0][1] = -curl[2];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
submit_gradient(grad, q_point);
}
evaluation_flags);
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <int dim, int n_components, typename value_type>
case 2:
return n_dofs_1d * n_dofs_1d * offset + n_dofs_1d * i + j;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
};
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// update DoF map
boundary_form = cross_product_3d(tangential_vectors[0],
tangential_vectors[1]);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
const VectorizedDouble JxW =
boundary_form.norm() *
}
if (update_flags & update_jacobian_grads)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
if (update_flags & update_normal_vectors)
for (unsigned int d = 0; d < dim; ++d)
}
if (update_flags & update_jacobian_grads)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
if (update_flags & update_normal_vectors)
for (unsigned int q = 0; q < fe_val.n_quadrature_points;
// FE_Nothing case -> nothing to do here
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
// Finally store the renumbering into the respective field
if (fe_in.n_components() == 1)
VectorizedArrayType *,
std::bool_constant<false>) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
VectorizedArrayType *,
std::bool_constant<false>) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
VectorizedArrayType *,
std::bool_constant<false>) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const unsigned int,
const unsigned int) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const unsigned int,
const unsigned int) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
coarse_grid_triangulations(fine_triangulation_in.n_global_levels());
#ifndef DEAL_II_WITH_P4EST
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
(void)policy;
(void)keep_fine_triangulation;
(void)repartition_fine_triangulation;
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {nullptr, numbers::invalid_unsigned_int};
}
}
OtherVectorType &,
const OtherVectorType &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
OtherVectorType &,
const OtherVectorType &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
{
(void)n_subdivisions;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
else if (reference_cell == ReferenceCells::Pyramid)
quadrature.push_back(*quadrature_pyramid);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
x_fe_values[i] =
const ComponentExtractor /*extract_component*/,
std::vector<Tensor<1, spacedim>> & /*patch_gradients*/) const override
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
/**
std::vector<std::vector<Tensor<1, spacedim>>>
& /*patch_gradients_system*/) const override
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const ComponentExtractor /*extract_component*/,
std::vector<Tensor<2, spacedim>> & /*patch_hessians*/) const override
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
/**
std::vector<std::vector<Tensor<2, spacedim>>>
& /*patch_hessians_system*/) const override
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
/**
const unsigned int cell_number,
const ComponentExtractor extract_component) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
(void)cell_number;
(void)extract_component;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// note that we do not have to traverse the list of cell data here because
std::make_shared<dealii::hp::FECollection<dim, spacedim>>(
FE_PyramidDGP<dim, spacedim>(1)));
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
return finite_elements;
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::numeric_limits<double>::lowest();
}
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::numeric_limits<double>::lowest();
}
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::numeric_limits<double>::lowest();
}
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::numeric_limits<double>::lowest();
}
}
Scratch &
operator=(const Scratch &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return *this;
}
if (!base.conforms(FiniteElementData<dim>::H1) &&
base.conforms(FiniteElementData<dim>::Hdiv) &&
fe_is_primitive)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
if (!base.conforms(FiniteElementData<dim>::H1) &&
base.conforms(FiniteElementData<dim>::Hcurl))
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
if (!base.conforms(FiniteElementData<dim>::H1) &&
base.conforms(FiniteElementData<dim>::Hdiv))
const Function<3, float> *const /*coefficient*/,
const std::vector<unsigned int> & /*component_mapping*/)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <>
const Function<3, double> *const /*coefficient*/,
const std::vector<unsigned int> & /*component_mapping*/)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
} // namespace internal
// dofs?
if (dim == 1)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return;
}
if (!base.conforms(FiniteElementData<dim>::H1) &&
base.conforms(FiniteElementData<dim>::Hdiv) &&
fe_is_primitive)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
if (!base.conforms(FiniteElementData<dim>::H1) &&
base.conforms(FiniteElementData<dim>::Hcurl))
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
if (!base.conforms(FiniteElementData<dim>::H1) &&
base.conforms(FiniteElementData<dim>::Hdiv))
// dofs?
if (dim == 1)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return;
}
dof_is_of_interest = true;
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
if (dof_is_of_interest)
{
dof_is_of_interest = true;
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
if (dof_is_of_interest)
{
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
const std::vector<DerivativeForm<1, dim, dim>> &,
AffineConstraints<number> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// This function computes the projection of the boundary function on the
std::vector<number> &,
std::vector<types::global_dof_index> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
} // namespace internals
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
} // namespace VectorTools
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
cross_product_3d(normals[0], normals[dim - 2]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(
case EvaluationFlags::insert:
return values[0];
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return values[0];
}
}
case EvaluationFlags::insert:
return values[0];
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return values[0];
}
}
case EvaluationFlags::insert:
return values[0];
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return values[0];
}
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
"solve_with_jacobian_and_track_n_linear_iterations function "
"has been attached to the NOXSolver object."));
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
ret_code = 1;
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return grad;
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
case 4:
return FourthOrder;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return Euler;
}
case (DataOutBase::CompressionLevel::default_compression):
return Z_DEFAULT_COMPRESSION;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return Z_NO_COMPRESSION;
}
}
case (DataOutBase::CompressionLevel::default_compression):
return boost::iostreams::zlib::default_compression;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return boost::iostreams::zlib::no_compression;
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return vtk_cell_id;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Point<spacedim> node;
for (unsigned int d = 0; d < spacedim; ++d)
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
stream << '\n';
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
stream << '\n';
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
stream << '\n';
}
case svg:
return ".svg";
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return "";
}
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// Update the number of the first vertex of this patch
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// Having so set up the 'connectivity' data structure,
}
else
// No other reference cells are currently implemented
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
// make sure everything now gets to disk
heights[i] = points[i][2];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
out << "\"x\", \"y\", \"z\"";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
for (unsigned int data_set = 0; data_set < n_data_sets; ++data_set)
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else // use higher-order output
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
const SvgFlags &,
std::ostream &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <int spacedim>
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
deal_II_intermediate_flags =
*reinterpret_cast<const DataOutBase::Deal_II_IntermediateFlags *>(&flags);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// If the exception stores a string representation of the violated
// condition, then output it. Not all exceptions do (e.g., when
- // creating an exception inside DEAL_II_NOT_IMPLEMENTED()), so
+ // creating an exception inside DEAL_II_NOT_IMPLEMENTED();), so
// we have to check whether there is anything to print.
if (cond != nullptr)
out << "The violated condition was: " << std::endl
std::size_t
FlowFunction<dim>::memory_consumption() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
f.value(p - 2 * incr[0], component)) /
(12 * h);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0.;
}
result /= (12. * h);
return;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
values[i] = (values[i] - 8. * aux[i]) / (12 * h);
return;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
return (1. - p[0] * p[0]) * (1. - p[1] * p[1]) * (1. - p[2] * p[2]) +
offset;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0.;
}
offset;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
(1. - p[1] * p[1]) * (1. - p[2] * p[2]) +
(1. - p[2] * p[2]) * (1. - p[0] * p[0]));
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0.;
}
(1. - p[2] * p[2]) * (1. - p[0] * p[0]));
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
result[2] = -2. * p[2] * (1. - p[0] * p[0]) * (1. - p[1] * p[1]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return result;
}
-2. * p[2] * (1. - p[0] * p[0]) * (1. - p[1] * p[1]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
std::cos(numbers::PI_2 * p[1]) *
std::cos(numbers::PI_2 * p[2]);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0.;
}
std::cos(numbers::PI_2 * p[1]) *
std::cos(numbers::PI_2 * p[2]);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0.;
}
std::sin(numbers::PI_2 * p[2]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return result;
}
std::cos(numbers::PI_2 * p[1]) * std::sin(numbers::PI_2 * p[2]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return result;
}
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
std::cos(numbers::PI_2 * p[d1]) *
std::cos(numbers::PI_2 * p[d2]));
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0.;
}
std::sin(numbers::PI_2 * p[2]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
std::cos(numbers::PI_2 * p[d2]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
std::sin(numbers::PI_2 * p[2]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
std::sin(numbers::PI_2 * p[d2]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return result;
}
std::sin(numbers::PI_2 * p[d2]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
case 3:
return std::exp(p[0]) * std::exp(p[1]) * std::exp(p[2]);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0.;
}
values[i] = std::exp(p[0]) * std::exp(p[1]) * std::exp(p[2]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
case 3:
return 3 * std::exp(p[0]) * std::exp(p[1]) * std::exp(p[2]);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0.;
}
values[i] = 3 * std::exp(p[0]) * std::exp(p[1]) * std::exp(p[2]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
result[2] = result[0];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return result;
}
gradients[i][2] = gradients[i][0];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
LSingularityGradFunction::gradient(const Point<2> & /*p*/,
const unsigned int /*component*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
std::vector<Tensor<1, 2>> & /*gradients*/,
const unsigned int /*component*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const std::vector<Point<2>> & /*points*/,
std::vector<std::vector<Tensor<1, 2>>> & /*gradients*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
//--------------------------------------------------------------------
angle = std::atan2(direction[0], direction[1]);
break;
case 3:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
sine = std::sin(angle);
cosine = std::cos(angle);
else if (dim == 2)
return compute_signed_distance_ellipse(point);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0.0;
}
const unsigned int /*component*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
Spherical<dim>::hessian(const Point<dim> & /*p*/,
const unsigned int /*component*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// dive recursively into the subsections
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// then the contents of the subsection
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
return u;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return "";
}
if (p != nullptr)
return p;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return p;
}
return 3 * (k + 3) * (k + 1) * (k + 1);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0;
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return BarycentricPolynomials<dim>(polys);
monomials[i] = Polynomials::Monomial<double>(i);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
return (k + 1) * (k + 2) + 2;
if (dim == 3)
return ((k + 1) * (k + 2) * (k + 3)) / 2 + 3 * (k + 1);
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
GeometryInfo<dim>::faces_per_cell;
// 2*4+4=12 polynomials in 2d and 3*8+6=30 polynomials in 3d
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
return 5;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
(void)i;
(void)p;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return Tensor<2, dim>();
}
(void)i;
(void)p;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
(void)i;
(void)p;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
(void)i;
(void)p;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
1.5 * (p[0] * p[0] - p[1] * p[1]));
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return grad;
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
}
if (dim == 1 || dim == 2 || dim == 3)
return dim * Utilities::fixed_power<dim>(k + 1);
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
return 18;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
(void)i;
(void)p;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return Tensor<2, dim>();
}
(void)i;
(void)p;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
(void)i;
(void)p;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
(void)i;
(void)p;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
QIterated<0>::QIterated(const Quadrature<1> &, const std::vector<Point<1>> &)
: Quadrature<0>()
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
QIterated<0>::QIterated(const Quadrature<1> &, const unsigned int)
: Quadrature<0>()
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
q_points[7] = 0.977520613561287499;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
return q_points;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
break;
case 2:
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
break;
case 6:
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(b_point_permutations.size() == b_weights.size(), ExcInternalError());
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
std::size_t
ScalarPolynomialsBase<dim>::memory_consumption() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
const unsigned int,
std::array<unsigned int, dim> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
inline void
TensorProductPolynomialsBubbles<0>::compute_value(const unsigned int,
const Point<0> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0.;
}
TensorProductPolynomialsConst<0>::compute_value(const unsigned int,
const Point<0> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0.;
}
output[section.first] = section.second.n_calls;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
return output;
return std::make_pair(i, 7U);
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::make_pair(-1, numbers::invalid_unsigned_int);
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
(void)tol;
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
void Triangulation<dim, spacedim>::execute_coarsening_and_refinement()
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
}
P8EST_QUADRANT_INIT(&p4est_children[c]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
P8EST_QUADRANT_INIT(&quad);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
functions<dim>::quadrant_set_morton(&quad,
/*level=*/0,
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
bool Triangulation<dim, spacedim>::with_artificial_cells() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return true;
}
const std::vector<unsigned int>
&Triangulation<dim, spacedim>::get_true_subdomain_ids_of_cells() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return true_subdomain_ids_of_cells;
}
&Triangulation<dim, spacedim>::get_true_level_subdomain_ids_of_cells(
const unsigned int) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return true_level_subdomain_ids_of_cells;
}
} // namespace shared
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else
P8EST_QUADRANT_INIT(&p4est_child[c]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
P8EST_QUADRANT_INIT(&p4est_child[c]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
P8EST_QUADRANT_INIT(&p4est_child[c]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
internal::p4est::functions<dim>::quadrant_childrenv(&p4est_cell,
p4est_child);
P8EST_QUADRANT_INIT(&p4est_child[c]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
dealii::internal::p4est::functions<dim>::quadrant_childrenv(
P8EST_QUADRANT_INIT(&p4est_child[c]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
dealii::internal::p4est::functions<dim>::quadrant_childrenv(
smooth_grid,
false)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
compute_level_vertices_with_ghost_neighbors(
const unsigned int /*level*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::map<unsigned int, std::set<dealii::types::subdomain_id>>();
}
std::vector<bool> Triangulation<1, spacedim>::
mark_locally_active_vertices_on_level(const unsigned int) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<bool>();
}
unsigned int Triangulation<1, spacedim>::
coarse_cell_id_to_coarse_cell_index(const types::coarse_cell_id) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
Triangulation<1, spacedim>::coarse_cell_index_to_coarse_cell_id(
const unsigned int) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<1, spacedim>))
void Triangulation<1, spacedim>::load(const std::string &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<1, spacedim>))
void Triangulation<1, spacedim>::load(const std::string &, const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<1, spacedim>))
void Triangulation<1, spacedim>::save(const std::string &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<1, spacedim>))
bool Triangulation<1, spacedim>::is_multilevel_hierarchy_constructed() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return false;
}
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<1, spacedim>))
bool Triangulation<1, spacedim>::are_vertices_communicated_to_p4est() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return false;
}
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<1, spacedim>))
void Triangulation<1, spacedim>::update_cell_relations()
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
} // namespace distributed
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
max_couplings = 0;
}
return std::min(max_couplings, dof_handler.n_dofs());
27 * dof_handler.fe_collection.max_dofs_per_hex();
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
max_couplings = 0;
}
28 * this->fe_collection.max_dofs_per_line() +
8 * this->fe_collection.max_dofs_per_quad());
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
#ifdef DEBUG
{
#ifndef DEAL_II_WITH_MPI
(void)new_numbers;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return NumberCache();
#else
// Similar to distribute_dofs() we need to have a special treatment in
const std::vector<types::global_dof_index> & /*new_numbers*/) const
{
// multigrid is not currently implemented for shared triangulations
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
{
# ifndef DEAL_II_WITH_MPI
(void)dof_handler;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
# else
// define functions that pack data on cells that are ghost cells
ParallelDistributed<dim, spacedim>::distribute_dofs() const
{
#ifndef DEAL_II_WITH_MPI
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return NumberCache();
#else
ParallelDistributed<dim, spacedim>::distribute_mg_dofs() const
{
#ifndef DEAL_II_WITH_MPI
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<NumberCache>();
#else
ExcInternalError());
#ifndef DEAL_II_WITH_MPI
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return NumberCache();
#else
(void)level;
(void)new_numbers;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return NumberCache();
#else
renumbering);
}
#else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
#endif
}
else
4 * this->n_dofs_per_quad(face_no),
this->n_dofs_per_face(face_no)};
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return {numbers::invalid_unsigned_int, numbers::invalid_unsigned_int};
}
FiniteElement<dim, spacedim>::hp_vertex_dof_identities(
const FiniteElement<dim, spacedim> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
FiniteElement<dim, spacedim>::hp_line_dof_identities(
const FiniteElement<dim, spacedim> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
const FiniteElement<dim, spacedim> &,
const unsigned int) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
const FiniteElement<dim, spacedim> &,
const unsigned int) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
std::pair<Table<2, bool>, std::vector<unsigned int>>
FiniteElement<dim, spacedim>::get_constant_modes() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::pair<Table<2, bool>, std::vector<unsigned int>>(
Table<2, bool>(this->n_components(), this->n_dofs_per_cell()),
std::vector<unsigned int>(this->n_components()));
"the glossary for a definition of generalized support "
"points). Consequently, the current function can not "
"be defined and is not implemented by the element."));
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
std::size_t
FE_ABF<dim>::memory_consumption() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
return std::vector<std::pair<unsigned int, unsigned int>>();
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return std::vector<std::pair<unsigned int, unsigned int>>();
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return std::vector<std::pair<unsigned int, unsigned int>>();
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
std::size_t
FE_DGP<dim, spacedim>::memory_consumption() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
void
FE_DGPMonomial<dim>::initialize_restriction()
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return std::vector<std::pair<unsigned int, unsigned int>>();
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return std::vector<std::pair<unsigned int, unsigned int>>();
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return std::vector<std::pair<unsigned int, unsigned int>>();
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
std::size_t
FE_DGPMonomial<dim>::memory_consumption() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
return std::vector<std::pair<unsigned int, unsigned int>>();
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return std::vector<std::pair<unsigned int, unsigned int>>();
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return std::vector<std::pair<unsigned int, unsigned int>>();
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
std::size_t
FE_DGPNonparametric<dim, spacedim>::memory_consumption() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return true;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
else if (const FE_Hermite<dim, spacedim> *fe_herm_other =
dynamic_cast<const FE_Hermite<dim, spacedim> *>(&fe_other))
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// We need to initialize the dof permutation table and the one for the sign
void
FE_Nedelec<1>::initialize_support_points(const unsigned int)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return false;
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return false;
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return false;
}
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
FullMatrix<double> &,
const unsigned int) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
std::size_t
FE_Nedelec<dim>::memory_consumption() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
return embedding_dofs;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<unsigned int>();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
const unsigned int /*component*/) const
{
// Not implemented yet:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0.;
}
const Point<dim> & /*p*/,
const unsigned int /*component*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return Tensor<1, dim>();
}
const Point<dim> & /*p*/,
const unsigned int /*component*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return Tensor<2, dim>();
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
return data_ptr;
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, dim>
& /*data*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
(mapping_kind == mapping_raviart_thomas) ||
(mapping_kind == mapping_nedelec))))
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
// third derivatives are not implemented
if (fe_data.update_each & update_3rd_derivatives)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
// third derivatives are not implemented
if (fe_data.update_each & update_3rd_derivatives)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return dpo;
if (degree == 1)
n_dofs = 5;
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return internal::expand(3, {{0, 0, 0, n_dofs}}, ReferenceCells::Pyramid);
}
}
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
return FiniteElementDomination::neither_element_dominates;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
tensor_const_poly_space_ptr->set_numbering(renumber);
return;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}();
// Finally fill in support points on cell and face and initialize
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return false;
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else if (shape_index < this->get_first_hex_index())
// dof is on a quad
if (dim == 3)
return (quad_index == face_index);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else
// dof on hex
{
// can only happen in 3d, but this case has already been covered above
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return false;
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return h2l;
}
if (dim == 3)
return (quad_index == face_index);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else
// dof on hex
// can only happen in 3d, but
// this case has already been
// covered above
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return false;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<unsigned int>();
}
}
std::size_t
FE_Q_Hierarchical<dim>::memory_consumption() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
std::size_t
FE_RaviartThomas<dim>::memory_consumption() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
return std::vector<std::pair<unsigned int, unsigned int>>();
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
((d == 2) ? low : high));
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
for (unsigned int k = 0; k < quadrature->size(); ++k)
case 3:
return {1, 2};
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
case 2:
switch (degree)
case 3:
return {1, 2, 1};
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
case 3:
switch (degree)
case 3:
return {1, 2, 1, 0};
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
continuous_dpo[dim]};
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
return points;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return points;
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// now that we gathered all information: use it to build the
base.hp_quad_dof_identities(base_other, face_no);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
for (const auto &base_identity : base_identities)
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::vector<std::pair<unsigned int, unsigned int>>();
}
}
return domination;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
if (shape_function_data[shape_function]
.is_nonzero_shape_function_component[d])
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
// the following implementation needs to be looked over -- I
// think it can't be right, because we are in a case where
if (shape_function_data[shape_function]
.is_nonzero_shape_function_component[d])
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
if (shape_function_data[shape_function]
.is_nonzero_shape_function_component[d])
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return dpo;
else if (degree == 2)
n_dofs = 18;
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return internal::expand(3, {{0, 0, 0, n_dofs}}, ReferenceCells::Wedge);
}
return FiniteElementDomination::no_requirements;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return FiniteElementDomination::neither_element_dominates;
}
const typename Triangulation<dim>::cell_iterator &,
std::vector<Point<dim>> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const typename Triangulation<dim>::cell_iterator &,
std::vector<Point<dim>> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
data.cell_extents[2] = cell->vertex(4)[2] - start[2];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
return;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
return;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
length[2] = cell->vertex(4)[2] - start[2];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Point<dim> p_real = cell->vertex(0);
Assert(is_cartesian(cell), ExcCellNotCartesian());
if (dim != spacedim)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
const Point<dim> &start = cell->vertex(0);
Point<dim> real = p;
real -= start;
real[2] /= cell->vertex(4)[2] - start[2];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return real;
}
cross_product_3d(data.aux[0][i], data.aux[1][i]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else //(dim < spacedim)
cell->subface_case(face_no), subface_no);
output_data.JxW_values[i] *= area_ratio;
#else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
#endif
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
return;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
} // namespace
output);
return;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
output);
return;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
MappingFEField<dim, spacedim, VectorType>::InternalData::memory_consumption()
const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
for (const unsigned int v : cell->vertex_indices())
vertices[v][comp] += fe_values.shape_value(i, v) * value;
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
cross_product_3d(data.aux[0][i], data.aux[1][i]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else //(dim < spacedim)
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
return;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
} // namespace
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
const typename Triangulation<dim, spacedim>::cell_iterator &,
const Point<spacedim> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
cross_product_3d(data.aux[0][i], data.aux[1][i]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else //(dim < spacedim)
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
return;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
} // namespace
input, mapping_kind, mapping_data, output);
return;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
input, mapping_kind, mapping_data, output);
return;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
const Point<3> &,
const Point<1> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
output);
return;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
output);
return;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
}
Assert(count == 48, ExcInternalError());
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// Prepare cell data
cells[3].material_id = 0;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
tria.create_triangulation(points, cells, SubCellData());
}
const Point<3> (& /*corners*/)[3],
const bool /*colorize*/)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <>
const Point<1> (& /*corners*/)[1],
const bool /*colorize*/)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// Implementation for 2d only
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// Prepare cell data
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// Create triangulation
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// next create the cells
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
tria.create_triangulation(points, cells, SubCellData());
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// next create the cells
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
tria.create_triangulation(points, cells, SubCellData());
// set boundary indicator
if (colorize)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// next create the cells
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
tria.create_triangulation(points, cells, SubCellData());
const unsigned int /*n_slices*/,
const bool /*colorize*/)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const double /*skewness*/,
const bool /*colorize*/)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
void
hyper_cube_slit(Triangulation<1> &, const double, const double, const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const double,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
void
hyper_L(Triangulation<1> &, const double, const double, const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
void
hyper_ball(Triangulation<1> &, const Point<1> &, const double, const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
void
hyper_ball_balanced(Triangulation<1> &, const Point<1> &, const double)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
void
cylinder(Triangulation<1> &, const double, const double)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const double,
const double)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
void
truncated_cone(Triangulation<1> &, const double, const double, const double)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const unsigned int,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <>
const unsigned int,
const unsigned int)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
void
quarter_hyper_ball(Triangulation<1> &, const Point<1> &, const double)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
void
half_hyper_ball(Triangulation<1> &, const Point<1> &, const double)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const unsigned int,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <>
const unsigned int,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <>
const double,
const double)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const unsigned int,
const unsigned int)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
if (colorize)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
const unsigned int,
const bool)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
};
manifold_id_cell);
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
// Set up sub-cell data.
for (const auto f : cell->face_indices())
add_cell(1, edge_vertices, bid, mid);
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// set manifold ids of edges that were already present in the
const std::pair<Point<spacedim>, double> &,
const double)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
Assert(false, ExcInternalError());
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// Then also read the "geometric entity indices". There need to
Assert(false, ExcInternalError());
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
void
GridIn<dim, spacedim>::read_tecplot(std::istream &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else if (type_name_2 == "HEX" || type_name_2 == "HEXAHEDRON")
return ReferenceCells::Hexahedron;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return ReferenceCells::Invalid;
}
const std::vector<Point<spacedim>> & /*vertices*/,
std::ostream & /*out*/)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
case tecplot:
return ".dat";
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return ".unknown_format";
}
}
case vtu:
return ".vtu";
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return "";
}
}
void
GridOut::write_dx(const Triangulation<1> &, std::ostream &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <>
void
GridOut::write_dx(const Triangulation<1, 2> &, std::ostream &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <>
void
GridOut::write_dx(const Triangulation<1, 3> &, std::ostream &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else if (cell->reference_cell() == ReferenceCells::get_simplex<dim>())
out << cell->vertex_index(vertex) + 1 << ' ';
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
out << '\n';
}
out << "hex ";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// it follows a list of the
std::ostream &,
const Mapping<dim, spacedim> *) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
GridOut::write_mathgl(const Triangulation<1> &, std::ostream &) const
{
// 1d specialization not done yet
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
out << "\nrotate 60 40";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
out << '\n';
<< '\n';
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// (iv) write a list of vertices of cells
out << cell->vertex_index(permutation_table[i]);
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
out << '\n';
}
out << "quad ";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// note: vertex numbers are 1-base
for (unsigned int vertex = 0;
out << '\n'; // end of second line
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else // need to handle curved boundaries
{
const GridOutFlags::Eps<2> &,
const GridOutFlags::Eps<3> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
void
const GridOutFlags::Eps<2> &,
const GridOutFlags::Eps<3> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
void
const GridOutFlags::Eps<2> &,
const GridOutFlags::Eps<3> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
void
const GridOutFlags::Eps<2> &,
const GridOutFlags::Eps<3> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
}
const bool solve_for_absolute_positions)
{
if (dim == 1)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
// first provide everything that is needed for solving a Laplace
// equation.
const std::vector<CellId> &,
std::vector<types::subdomain_id> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
} // anonymous namespace
} // namespace internal
const parallel::fullydistributed::Triangulation<dim, spacedim> *>(
&triangulation) != nullptr)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else if (const parallel::distributed::Triangulation<dim, spacedim>
*parallel_tria = dynamic_cast<
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
if (angle_fraction > limit_angle_fraction)
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
if (dim == 1)
return 0;
if (dim == 2 && spacedim == 3)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
std::size_t n_negative_cells = 0;
std::size_t cell_no = 0;
throw ExcMeshNotOrientable();
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// now rotate raw_cells[cell_index] in such a way that its orientation
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
// we get here from FlatManifold<2,3>::normal_vector, but
// the implementation below is bogus for this case anyway
// (see the assert at the beginning of that function).
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
const Triangulation<1, 2>::face_iterator &,
Manifold<1, 2>::FaceVertexNormals &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const Triangulation<1, 3>::face_iterator &,
Manifold<1, 3>::FaceVertexNormals &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const Triangulation<2, 3>::face_iterator & /*face*/,
Manifold<2, 3>::FaceVertexNormals & /*face_vertex_normals*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
FlatManifold<1, 1>::normal_vector(const Triangulation<1, 1>::face_iterator &,
const Point<1> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
FlatManifold<1, 2>::normal_vector(const Triangulation<1, 2>::face_iterator &,
const Point<2> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
FlatManifold<1, 3>::normal_vector(const Triangulation<1, 3>::face_iterator &,
const Point<3> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return p + center;
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return p;
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return DX;
}
const ArrayView<const double> & /*weights*/,
const Point<spacedim> & /*candidate_point*/)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
Point<spacedim>
EllipticalManifold<dim, spacedim>::push_forward(const Point<spacedim> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
Point<spacedim>
EllipticalManifold<dim, spacedim>::pull_back(const Point<spacedim> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
EllipticalManifold<dim, spacedim>::push_forward_gradient(
const Point<spacedim> &) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
case ReferenceCells::Invalid:
return "Invalid";
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return "Invalid";
FE_WedgeP<dim, spacedim>(degree));
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return std::make_unique<MappingQ<dim, spacedim>>(degree);
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return StaticMappingQ1<dim, spacedim>::mapping; // never reached
else if (*this == ReferenceCells::Wedge)
return QGaussWedge<dim>(n_points_1d);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return Quadrature<dim>(); // never reached
}
return quadrature;
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
static const Quadrature<dim> dummy;
return dummy; // never reached
return exodus_to_deal[vertex_n];
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
return exodus_to_deal[face_n];
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
return unv_to_deal[vertex_n];
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return numbers::invalid_unsigned_int;
}
case ReferenceCells::Invalid:
return VTKCellType::VTK_INVALID;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return VTKCellType::VTK_INVALID;
case ReferenceCells::Invalid:
return VTKCellType::VTK_INVALID;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return VTKCellType::VTK_INVALID;
case ReferenceCells::Invalid:
return VTKCellType::VTK_INVALID;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return VTKCellType::VTK_INVALID;
const std::array<unsigned, 0> &,
const bool) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
const std::array<unsigned, 1> &,
const bool) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
case ReferenceCells::Invalid:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return numbers::invalid_unsigned_int;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
return 5;
case ReferenceCells::Invalid:
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return numbers::invalid_unsigned_int;
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
// We should be within 4 * eps of the cell by this point. The roundoff error
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
for (const unsigned int line : quad->line_indices())
line_indices[quad_lines[i][2]],
line_indices[quad_lines[i][3]]});
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
new_quad->set_used_flag();
new_quad->clear_user_flag();
n_new_hexes = 8;
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
std::array<raw_line_iterator, 6> new_lines;
for (unsigned int i = 0; i < n_new_lines; ++i)
AssertDimension(k, 13);
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
boost::container::small_vector<unsigned int, 30>
relevant_line_indices(relevant_lines.size());
relevant_line_indices[new_quad_lines[q][2]],
relevant_line_indices[new_quad_lines[q][3]]});
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
// On hexes, we must only determine a single line
// according to the representative_lines array above
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
static constexpr dealii::ndarray<unsigned int, 8, 6>
quad_indices[cell_quads[c][4]],
quad_indices[cell_quads[c][5]]});
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// for hexes, we can simply inherit the orientation values
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
} // namespace
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
} // namespace
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
} // namespace
save_user_flags_hex(out);
if (dim >= 4)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
if (dim >= 4)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
load_user_flags_hex(in);
if (dim >= 4)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
if (dim >= 4)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
if (dim >= 4)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
if (dim >= 4)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <int dim, int spacedim>
}
if (dim >= 4)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
if (dim >= 4)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
case 3:
return begin_raw_hex(level);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return raw_cell_iterator();
}
}
case 3:
return begin_active_hex(level);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return active_cell_iterator();
}
}
case 3:
return begin_quad();
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return face_iterator();
}
}
case 3:
return begin_active_quad();
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return active_face_iterator();
}
}
case 3:
return end_quad();
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return raw_face_iterator();
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return raw_hex_iterator();
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return raw_hex_iterator();
}
}
case 3:
return n_quads();
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0;
}
case 3:
return n_raw_quads();
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0;
}
case 3:
return n_active_quads();
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0;
}
case 3:
return n_raw_hexs(level);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0;
}
case 3:
return n_hexs(level);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0;
}
case 3:
return n_active_hexs(level);
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0;
}
{
if (dim == 1)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
unsigned int Triangulation<dim, spacedim>::n_raw_quads() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
{
// this function catches all the cases not
// explicitly handled above
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
return 0.5 * cross_product_3d(v01, v02).norm();
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0.0;
}
{
// catch-all for all cases not explicitly
// listed above
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::numeric_limits<double>::quiet_NaN();
}
TriaAccessor<structdim, dim, spacedim>::extent_in_direction(
const unsigned int /*axis*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return std::numeric_limits<double>::signaling_NaN();
}
TriaAccessor<0, 1, spacedim>::user_flag_set() const
{
Assert(this->used(), TriaAccessorExceptions::ExcCellNotUsed());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return true;
}
TriaAccessor<0, 1, spacedim>::set_user_flag() const
{
Assert(this->used(), TriaAccessorExceptions::ExcCellNotUsed());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
TriaAccessor<0, 1, spacedim>::clear_user_flag() const
{
Assert(this->used(), TriaAccessorExceptions::ExcCellNotUsed());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
TriaAccessor<0, 1, spacedim>::clear_user_data() const
{
Assert(this->used(), TriaAccessorExceptions::ExcCellNotUsed());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
TriaAccessor<0, 1, spacedim>::set_user_pointer(void *) const
{
Assert(this->used(), TriaAccessorExceptions::ExcCellNotUsed());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
TriaAccessor<0, 1, spacedim>::clear_user_pointer() const
{
Assert(this->used(), TriaAccessorExceptions::ExcCellNotUsed());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
TriaAccessor<0, 1, spacedim>::user_pointer() const
{
Assert(this->used(), TriaAccessorExceptions::ExcCellNotUsed());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return nullptr;
}
TriaAccessor<0, 1, spacedim>::set_user_index(const unsigned int) const
{
Assert(this->used(), TriaAccessorExceptions::ExcCellNotUsed());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
TriaAccessor<0, 1, spacedim>::clear_user_index() const
{
Assert(this->used(), TriaAccessorExceptions::ExcCellNotUsed());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
TriaAccessor<0, 1, spacedim>::user_index() const
{
Assert(this->used(), TriaAccessorExceptions::ExcCellNotUsed());
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
// if no reference cell type matches
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return TriaIterator<CellAccessor<dim, spacedim>>();
}
}
// if no reference cell type matches
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return TriaIterator<CellAccessor<dim, spacedim>>();
}
default:
// if 1d or more than 3d
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return TriaIterator<CellAccessor<dim, spacedim>>();
}
}
LinearAlgebra::CUDAWrappers::Vector<Number> & /*dst*/,
const LinearAlgebra::CUDAWrappers::Vector<Number> & /*src*/) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
string_type = "None";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return string_type;
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
PetscFunctionReturn(PETSC_SUCCESS);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
solver.SetAztecOption(AZ_solver, AZ_tfqmr);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// Set the preconditioner
void
SparseMatrix::write_ascii()
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
SparsityPattern &
SparsityPattern::operator=(const SparsityPattern &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return *this;
}
void
SparsityPattern::write_ascii()
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
std::size_t
SparsityPattern::memory_consumption() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
SparsityPattern<MemorySpace>::operator=(
const SparsityPattern<MemorySpace> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return *this;
}
# else
(void)i;
(void)j;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return false;
# endif
}
std::size_t
SparsityPattern<MemorySpace>::memory_consumption() const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
&fe_poly_ptr->get_poly_space()))
return polyspace->get_underlying_polynomials();
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
} // namespace FEPointEvaluation
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
++ki;
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
if (++ki == ghost_indices_subset_data.second[ko].second)
std::vector<unsigned int> &,
const DoFTools::Coupling)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const Table<2, DoFTools::Coupling> &,
const Table<2, DoFTools::Coupling> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
std::vector<unsigned int> &,
const DoFTools::Coupling)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const Table<2, DoFTools::Coupling> &,
const Table<2, DoFTools::Coupling> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
{
// would this function make any sense after all? who would want to
// output/compute in four space dimensions?
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return;
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// then fill in data
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
else
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// needs to be employed. maybe some
// steps of the power method would
// suffice?
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
const ArrayView<const Point<spacedim>> &,
const Point<spacedim> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return ranges;
check_tensor_product(const std::vector<Quadrature<dim>> &quadratures,
const std::vector<std::string> &quadrature_names)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <>
std::swap(vertices[0], vertices[1]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
std::swap(vertices[1], vertices[0]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
convection[2] = 1;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return convection;
}
convection[2] = 1;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return convection;
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
gmv_filename = "solution-adaptive";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
switch ((*fe).degree)
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
gmv_filename += ".gmv";
error_filename += "-adaptive";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
switch ((*fe).degree)
error_filename += "-q2";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
error_filename += ".tex";
conv_filename += "-adaptive";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
switch ((*fe).degree)
{
conv_filename += "-q2";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
conv_filename += ".tex";
solution_names.push_back("z_displacement");
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
data_out.add_data_vector(solution, solution_names);
}
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
table.set_scientific("L^2 norm error", true);
table.evaluate_convergence_rates("L^2 norm error",
case 1:
return std::cos(p.norm());
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
case 1:
return std::cos(p.norm());
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
case 1:
return std::cos(p.norm());
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
case 1:
return std::cos(p.norm());
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// Prepare cell data
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// Prepare cell data
case 1:
return std::cos(p[0]) * std::cos(3.0 * p[1]) + 2.0;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return 0.0;
}
}
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
/* A is
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
else if (cell->material_id() == pou_material_id)
cell->set_active_fe_index(pou_fe_index);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
GridTools::partition_triangulation(n_mpi_processes, triangulation);
else if (cell->material_id() == pou_material_id)
cell->set_active_fe_index(pou_fe_index);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
GridTools::partition_triangulation(n_mpi_processes, triangulation);
function1_back);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
DataOut<dim> data_out;
file2_name += fe_string2 + "_interpolation_diff.gnuplot";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
deallog << file2_name << std::endl;
return point[1] + 0.25 * (2 * x - 1.0) * (x - 1.0) * x;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return std::numeric_limits<double>::quiet_NaN();
}
return point[1] - 0.25 * (2 * x - 1.0) * (x - 1.0) * x;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
return std::numeric_limits<double>::quiet_NaN();
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// now check with data from the
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
p[1] * (1 + p[0]) * (1 + p[2]),
p[2] * (1 + p[0]) * (1 + p[1]));
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return Point<dim>();
};
}
void
create_triangulation(const unsigned int, Triangulation<dim> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
// *------------>x
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
GridGenerator::hyper_cube(tria, 1., 4.);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
coarsen_centers.push_back(Point<dim>(5. / 8., 5. / 8., 5. / 8.));
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
unsigned int index = 0;
for (typename Triangulation<dim>::active_cell_iterator cell =
void
create_triangulation(const unsigned int, Triangulation<dim> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
void
create_triangulation(const unsigned int, Triangulation<dim> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
shift[d] = 1;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
GridTools::shift(shift, tria_2);
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
break;
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const unsigned n_fourier_modes = k_vectors.size();
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const unsigned n_fourier_modes = k_vectors.size();
p2[1] = p2[2] = 1.0;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
GridGenerator::subdivided_hyper_rectangle(triangulation,
p2[1] = p2[2] = 1.0;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
GridGenerator::subdivided_hyper_rectangle(triangulation,
(std::next((++(triangulation.begin_active()))))->set_refine_flag();
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
triangulation.execute_coarsening_and_refinement();
(std::next((++(triangulation.begin_active()))))->set_refine_flag();
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
triangulation.execute_coarsening_and_refinement();
else if (cell_is_in_omega2_domain(cell))
cell->set_active_fe_index(1);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
gmv_filename = "solution-adaptive";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
switch ((*fe)[0].degree)
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
gmv_filename += ".gmv";
error_filename += "-adaptive";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
switch ((*fe)[0].degree)
error_filename += "-q2";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
error_filename += ".tex";
conv_filename += "-adaptive";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
switch ((*fe)[0].degree)
{
conv_filename += "-q2";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
conv_filename += ".tex";
solution_names.push_back("z_displacement");
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
data_out.add_data_vector(solution, solution_names);
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const unsigned n_fourier_modes = k_vectors.size();
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
ilu_pattern.compress();
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
ilu_pattern.compress();
SparseILU<double>::AdditionalData data;
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
};
mic_pattern.compress();
SparseMIC<double>::AdditionalData data;
std::vector<Manifold<dim> *> &,
std::vector<double> &)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else if (geometry == 2)
GridGenerator::hyper_ball(tria);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
tria.reset_all_manifolds();
else if (geometry == 2)
GridGenerator::hyper_ball(tria);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
tria.reset_all_manifolds();
else if (cell->reference_cell() == ReferenceCells::Quadrilateral)
cell->set_active_fe_index(1);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const hp::MappingCollection<2> mapping(MappingFE<2>(FE_SimplexP<2>(1)),
return 64.0;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0.0;
}
// iterations of our two-stage outer GMRES iteration)
if (do_solve_A == true)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else
{
void
StokesOperator<dim, degree_v, number>::compute_diagonal()
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
const unsigned int col) const
{
(void)col;
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0.;
}
}
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
TrilinosWrappers::SparsityPattern sp(row_partitioning,
col_partitioning,
}
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
TrilinosWrappers::SparsityPattern sp(row_partitioning,
col_partitioning,
}
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
TrilinosWrappers::SparsityPattern sp(row_partitioning,
col_partitioning,
}
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
TrilinosWrappers::SparsityPattern sp(row_partitioning,
col_partitioning,
locally_owned.add_range(2, n_rows);
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
TrilinosWrappers::SparsityPattern sp(locally_owned,
locally_owned,
}
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
TrilinosWrappers::SparsityPattern sp(row_partitioning,
col_partitioning,
}
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
TrilinosWrappers::SparsityPattern sp(row_partitioning,
col_partitioning,
}
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
TrilinosWrappers::SparsityPattern sp(row_partitioning,
col_partitioning,
}
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
TrilinosWrappers::SparsityPattern sp(row_partitioning,
col_partitioning,
Number
el(unsigned int, unsigned int) const
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0;
}
// iterations of our two-stage outer GMRES iteration)
if (do_solve_A == true)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else
{
void
StokesOperator<dim, degree_v, number>::compute_diagonal()
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
v(2) = p[2];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
};
// iterations of our two-stage outer GMRES iteration)
if (do_solve_A == true)
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
else
{
void
StokesOperator<dim, degree_v, number>::compute_diagonal()
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
v(2) = p[2];
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
};
(std::next((++(triangulation.begin_active()))))->set_refine_flag();
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
triangulation.execute_coarsening_and_refinement();
(std::next((++(triangulation.begin_active()))))->set_refine_flag();
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
triangulation.execute_coarsening_and_refinement();
exact[3] = std::complex<double>(3. * pi, 1. - 6. * pi2) / (36. * pi3);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
break;
}
}
else
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
#else
(void)subcommunicator;
else if (typeid(PetscScalar) == typeid(float))
deallog << "float" << std::endl;
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0.;
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
triangulation.refine_global(n_global_refinements);
solution_names.push_back("delta_z");
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
data_out.add_data_vector(incremental_displacement, solution_names);
Vector<double> norm_of_stress(triangulation.n_active_cells());
solution_names.push_back("delta_z");
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
data_out.add_data_vector(incremental_displacement, solution_names);
Vector<double> norm_of_stress(triangulation.n_active_cells());
if (std::abs(evaluation_points[i][0] - evaluation_point_results[i]) >
1e-10 ||
std::abs(evaluation_point_gradient_results[i][0] - 1.0) > 1e-10)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
deallog << "OK!" << std::endl;
evaluation_point_results_2[i]) > 1e-10 ||
std::abs(evaluation_point_results_1[i] -
evaluation_point_results_3[i]) > 1e-10)
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
deallog << "OK!" << std::endl;
void
test()
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <>
else if (cell->reference_cell() == ReferenceCells::Quadrilateral)
cell->set_active_fe_index(1);
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
dof_handler.distribute_dofs(fe);
fe_mapping = std::make_shared<FE_PyramidP<dim>>(1);
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
MappingFE<dim> mapping(*fe_mapping);
else if (i == 2)
deallog.push("PYRAMID");
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
if (i == 0) // 2D makes only sense for simplex
{
return 64.0;
}
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0.0;
}
QGaussSimplex<dim - 1>(degree + 1)};
}
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
MappingFE<dim> mapping(*fe_mapping);
else if (i == 2)
deallog.push("PYRAMID");
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
if (i == 0) // 2D makes only sense for simplex
{
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
}
vtk_filename = "solution-adaptive";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
switch (fe->degree)
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
vtk_filename += ".vtk";
error_filename += "-adaptive";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
switch (fe->degree)
error_filename += "-q2";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
error_filename += ".tex";
conv_filename += "-adaptive";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
switch (fe->degree)
{
conv_filename += "-q2";
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
conv_filename += ".tex";
solution_names.emplace_back("z_displacement");
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
data_out.add_data_vector(solution, solution_names);
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return 0.;
}
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
return {};
}
}
}
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
#ifdef HEX
triangulation.refine_global(n_global_refinements);
}
default:
{
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
deallog << " Number of active cells : "
51);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
deallog << "Eigenvalues:";
else if (std::is_same_v<number, double>)
deallog << " Tensor<2, " << dim << ", double>" << std::endl;
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
template <int dim, typename number>
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
check(A);
}
else if (typeid(TrilinosScalar) == typeid(float))
deallog << "float" << std::endl;
else
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
26);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
SolverCG<Vector<double>> cg(control,
26);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
deallog << "Sparse Factorization" << std::endl;
values[5] = 2 * (p[2] + p[0] * p[1]);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
}
};
true_value = std::sqrt(29.0 / 3.0);
break;
default:
- Assert(false, ExcNotImplemented());
+ DEAL_II_NOT_IMPLEMENTED();
}
test<dim>(VectorTools::Hdiv_seminorm, true_value);
projects / dealii.git / commitdiff