/**
* Return the scalar product of the vectors representing two points.
*/
- double operator*(const PointWrapper &p) const;
+ double
+ operator*(const PointWrapper &p) const;
/**
* Add an offset to a point.
/**
* Multiply the coordinates of the point by a factor.
*/
- PointWrapper operator*(const double factor) const;
+ PointWrapper
+ operator*(const double factor) const;
/**
* Add another point.
- double PointWrapper::operator*(const PointWrapper &p) const
+ double
+ PointWrapper::operator*(const PointWrapper &p) const
{
AssertThrow(p.get_dim() == dim,
ExcMessage("The points do not have the same dimension."));
}
- PointWrapper PointWrapper::operator*(const double factor) const
+ PointWrapper
+ PointWrapper::operator*(const double factor) const
{
if (dim == 2)
return PointWrapper(
// Now for the function that is mainly of interest in this class, the
// computation of the point value:
template <int dim>
- void PointValueEvaluation<dim>::
- operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ void
+ PointValueEvaluation<dim>::operator()(const DoFHandler<dim> &dof_handler,
+ const Vector<double> & solution) const
{
// First allocate a variable that will hold the point value. Initialize
// it with a value that is clearly bogus, so that if we fail to set it
template <int dim>
- void PointValueEvaluation<dim>::
- operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ void
+ PointValueEvaluation<dim>::operator()(const DoFHandler<dim> &dof_handler,
+ const Vector<double> & solution) const
{
double point_value = 1e20;
// The more interesting things happen inside the function doing the actual
// evaluation:
template <int dim>
- void PointXDerivativeEvaluation<dim>::
- operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ void PointXDerivativeEvaluation<dim>::operator()(
+ const DoFHandler<dim> &dof_handler,
+ const Vector<double> & solution) const
{
// This time initialize the return value with something useful, since we
// will have to add up a number of contributions and take the mean value
std::vector<Tensor<2, dim>> k_inverse_values(n_q_points);
std::vector<Vector<double>> old_solution_values(n_q_points,
- Vector<double>(dim + 2));
+ Vector<double>(dim + 2));
std::vector<std::vector<Tensor<1, dim>>> old_solution_grads(
n_q_points, std::vector<Tensor<1, dim>>(dim + 2));
void setup_system();
void assemble_system();
void
- assemble_mass_matrix_diagonal(TrilinosWrappers::SparseMatrix &mass_matrix);
+ assemble_mass_matrix_diagonal(TrilinosWrappers::SparseMatrix &mass_matrix);
void update_solution_and_constraints();
void solve();
void output_results(const unsigned int iteration) const;
void compute_dirichlet_constraints();
void update_solution_and_constraints();
void
- assemble_mass_matrix_diagonal(TrilinosWrappers::SparseMatrix &mass_matrix);
+ assemble_mass_matrix_diagonal(TrilinosWrappers::SparseMatrix &mass_matrix);
void assemble_newton_system(
const TrilinosWrappers::MPI::Vector &linearization_point);
void compute_nonlinear_residual(
// the two terms on the left-hand side correspond to the two function calls
// here:
template <int dim, int fe_degree>
- __device__ void HelmholtzOperatorQuad<dim, fe_degree>::
- operator()(CUDAWrappers::FEEvaluation<dim, fe_degree> *fe_eval) const
+ __device__ void HelmholtzOperatorQuad<dim, fe_degree>::operator()(
+ CUDAWrappers::FEEvaluation<dim, fe_degree> *fe_eval) const
{
fe_eval->submit_value(coef * fe_eval->get_value());
fe_eval->submit_gradient(fe_eval->get_gradient());
// In addition, we also keep a solution vector with CPU storage such that we
// can view and display the solution as usual.
LinearAlgebra::distributed::Vector<double, MemorySpace::Host>
- ghost_solution_host;
+ ghost_solution_host;
LinearAlgebra::distributed::Vector<double, MemorySpace::CUDA> solution_dev;
LinearAlgebra::distributed::Vector<double, MemorySpace::CUDA>
system_rhs_dev;
std::string arguments_for_solid_grid = spacedim == 2 ?
"-.5, -.1: .5, .1: false" :
"-.5, -.1, -.1: .5, .1, .1: false";
- std::string name_of_particle_grid = "hyper_ball";
+ std::string name_of_particle_grid = "hyper_ball";
std::string arguments_for_particle_grid =
spacedim == 2 ? "0.3, 0.3: 0.1: false" : "0.3, 0.3, 0.3 : 0.1: false";
Type &
get_or_add_object_with_name(const std::string &name,
Arg & argument,
- Args &... arguments);
+ Args &...arguments);
/**
* Return a reference to the object with given name. If the object does
Type &
get_or_add_object_with_name(const std::string &name,
Arg && argument,
- Args &&... arguments);
+ Args &&...arguments);
/**
* Return a reference to the object with given name. If the object does
Type &
GeneralDataStorage::get_or_add_object_with_name(const std::string &name,
Arg & argument,
- Args &... arguments)
+ Args &...arguments)
{
if (!stores_object_with_name(name))
add_unique_copy(name, Type(argument, arguments...));
Type &
GeneralDataStorage::get_or_add_object_with_name(const std::string &name,
Arg && argument,
- Args &&... arguments)
+ Args &&...arguments)
{
if (!stores_object_with_name(name))
add_unique_copy(name,
/**
* Read-write access to entry @p index in the vector.
*/
- reference operator[](const size_type index);
+ reference
+ operator[](const size_type index);
/**
* Read-only access to entry @p index in the vector.
*/
- const_reference operator[](const size_type index) const;
+ const_reference
+ operator[](const size_type index) const;
/**
* Return a pointer to the underlying data buffer.
template <class T>
-inline typename AlignedVector<T>::reference AlignedVector<T>::
- operator[](const size_type index)
+inline typename AlignedVector<T>::reference
+AlignedVector<T>::operator[](const size_type index)
{
AssertIndexRange(index, size());
return elements[index];
template <class T>
-inline typename AlignedVector<T>::const_reference AlignedVector<T>::
- operator[](const size_type index) const
+inline typename AlignedVector<T>::const_reference
+AlignedVector<T>::operator[](const size_type index) const
{
AssertIndexRange(index, size());
return elements[index];
* This function is only allowed to be called if the underlying data is indeed
* stored in CPU memory.
*/
- value_type &operator[](const std::size_t i) const;
+ value_type &
+ operator[](const std::size_t i) const;
private:
/**
template <typename ElementType, typename MemorySpaceType>
inline bool
-ArrayView<ElementType, MemorySpaceType>::
-operator==(const ArrayView<const value_type, MemorySpaceType> &other_view) const
+ArrayView<ElementType, MemorySpaceType>::operator==(
+ const ArrayView<const value_type, MemorySpaceType> &other_view) const
{
return (other_view.data() == starting_element) &&
(other_view.size() == n_elements);
template <typename ElementType, typename MemorySpaceType>
inline bool
-ArrayView<ElementType, MemorySpaceType>::
-operator==(const ArrayView<typename std::remove_cv<value_type>::type,
- MemorySpaceType> &other_view) const
+ArrayView<ElementType, MemorySpaceType>::operator==(
+ const ArrayView<typename std::remove_cv<value_type>::type, MemorySpaceType>
+ &other_view) const
{
return (other_view.data() == starting_element) &&
(other_view.size() == n_elements);
template <typename ElementType, typename MemorySpaceType>
inline bool
-ArrayView<ElementType, MemorySpaceType>::
-operator!=(const ArrayView<const value_type, MemorySpaceType> &other_view) const
+ArrayView<ElementType, MemorySpaceType>::operator!=(
+ const ArrayView<const value_type, MemorySpaceType> &other_view) const
{
return !(*this == other_view);
}
template <typename ElementType, typename MemorySpaceType>
inline bool
-ArrayView<ElementType, MemorySpaceType>::
-operator!=(const ArrayView<typename std::remove_cv<value_type>::type,
- MemorySpaceType> &other_view) const
+ArrayView<ElementType, MemorySpaceType>::operator!=(
+ const ArrayView<typename std::remove_cv<value_type>::type, MemorySpaceType>
+ &other_view) const
{
return !(*this == other_view);
}
template <typename ElementType, typename MemorySpaceType>
inline typename ArrayView<ElementType, MemorySpaceType>::value_type &
- ArrayView<ElementType, MemorySpaceType>::operator[](const std::size_t i) const
+ArrayView<ElementType, MemorySpaceType>::operator[](const std::size_t i) const
{
AssertIndexRange(i, n_elements);
Assert(
*/
template <typename ElementType>
inline ArrayView<ElementType>
- make_array_view(Table<2, ElementType> & table,
- const typename Table<2, ElementType>::size_type row)
+make_array_view(Table<2, ElementType> & table,
+ const typename Table<2, ElementType>::size_type row)
{
AssertIndexRange(row, table.size()[0]);
return ArrayView<ElementType>(&table[row][0], table.size()[1]);
* @relatesalso ArrayView
*/
template <typename ElementType>
-inline ArrayView<ElementType> make_array_view(Table<2, ElementType> &table)
+inline ArrayView<ElementType>
+make_array_view(Table<2, ElementType> &table)
{
return ArrayView<ElementType>(&table[0][0], table.n_elements());
}
* @relatesalso ArrayView
*/
template <typename ElementType>
-inline ArrayView<ElementType> make_array_view(
- Table<2, ElementType> & table,
- const typename Table<2, ElementType>::size_type row,
- const typename Table<2, ElementType>::size_type starting_column,
- const std::size_t size_of_view)
+inline ArrayView<ElementType>
+make_array_view(Table<2, ElementType> & table,
+ const typename Table<2, ElementType>::size_type row,
+ const typename Table<2, ElementType>::size_type starting_column,
+ const std::size_t size_of_view)
{
AssertIndexRange(row, table.size()[0]);
AssertIndexRange(starting_column, table.size()[1]);
template <int spacedim, typename Number>
inline bool
-BoundingBox<spacedim, Number>::
-operator==(const BoundingBox<spacedim, Number> &box) const
+BoundingBox<spacedim, Number>::operator==(
+ const BoundingBox<spacedim, Number> &box) const
{
return boundary_points == box.boundary_points;
}
template <int spacedim, typename Number>
inline bool
-BoundingBox<spacedim, Number>::
-operator!=(const BoundingBox<spacedim, Number> &box) const
+BoundingBox<spacedim, Number>::operator!=(
+ const BoundingBox<spacedim, Number> &box) const
{
return boundary_points != box.boundary_points;
}
/**
* Swap the current object's contents with those of the given argument.
*/
- void swap(Patch<0, spacedim> &other_patch);
+ void
+ swap(Patch<0, spacedim> &other_patch);
/**
* Value to be used if this patch has no neighbor on one side.
/**
* Read-Write access operator.
*/
- Tensor<order, dim, Number> &operator[](const unsigned int i);
+ Tensor<order, dim, Number> &
+ operator[](const unsigned int i);
/**
* Read-only access operator.
*/
- const Tensor<order, dim, Number> &operator[](const unsigned int i) const;
+ const Tensor<order, dim, Number> &
+ operator[](const unsigned int i) const;
/**
* Assignment operator.
template <int order, int dim, int spacedim, typename Number>
inline DerivativeForm<order, dim, spacedim, Number> &
-DerivativeForm<order, dim, spacedim, Number>::
-operator=(const Tensor<order + 1, dim, Number> &ta)
+DerivativeForm<order, dim, spacedim, Number>::operator=(
+ const Tensor<order + 1, dim, Number> &ta)
{
Assert((dim == spacedim), ExcMessage("Only allowed when dim==spacedim."));
template <int order, int dim, int spacedim, typename Number>
inline DerivativeForm<order, dim, spacedim, Number> &
-DerivativeForm<order, dim, spacedim, Number>::
-operator=(const Tensor<order, spacedim, Tensor<1, dim, Number>> &T)
+DerivativeForm<order, dim, spacedim, Number>::operator=(
+ const Tensor<order, spacedim, Tensor<1, dim, Number>> &T)
{
for (unsigned int j = 0; j < spacedim; ++j)
(*this)[j] = T[j];
template <int order, int dim, int spacedim, typename Number>
inline DerivativeForm<order, dim, spacedim, Number> &
-DerivativeForm<order, dim, spacedim, Number>::
-operator=(const Tensor<1, dim, Number> &T)
+DerivativeForm<order, dim, spacedim, Number>::operator=(
+ const Tensor<1, dim, Number> &T)
{
Assert((1 == spacedim) && (order == 1),
ExcMessage("Only allowed for spacedim==1 and order==1."));
template <int order, int dim, int spacedim, typename Number>
inline Tensor<order, dim, Number> &
- DerivativeForm<order, dim, spacedim, Number>::operator[](const unsigned int i)
+DerivativeForm<order, dim, spacedim, Number>::operator[](const unsigned int i)
{
AssertIndexRange(i, spacedim);
template <int order, int dim, int spacedim, typename Number>
inline const Tensor<order, dim, Number> &
- DerivativeForm<order, dim, spacedim, Number>::
- operator[](const unsigned int i) const
+DerivativeForm<order, dim, spacedim, Number>::operator[](
+ const unsigned int i) const
{
AssertIndexRange(i, spacedim);
const char * function,
const char * cond,
const char * exc_name,
- ExceptionType e) {
+ ExceptionType e)
+ {
// Fill the fields of the exception object
e.set_fields(file, line, function, cond, exc_name);
/**
* Internal function that does the work of issue_error_nothrow.
*/
- void do_issue_error_nothrow(const ExceptionBase &e) noexcept;
+ void
+ do_issue_error_nothrow(const ExceptionBase &e) noexcept;
/**
* Exception generation mechanism in case we must not throw.
* Return the intersection of the refinement flags represented by the
* current object and the one given as argument.
*/
- RefinementCase operator&(const RefinementCase &r) const;
+ RefinementCase
+ operator&(const RefinementCase &r) const;
/**
* Return the negation of the refinement flags represented by the current
template <int dim>
-inline RefinementCase<dim> RefinementCase<dim>::
- operator&(const RefinementCase<dim> &r) const
+inline RefinementCase<dim>
+RefinementCase<dim>::operator&(const RefinementCase<dim> &r) const
{
return RefinementCase<dim>(static_cast<std::uint8_t>(value & r.value));
}
* sets must have the same size (though of course they do not have to have
* the same number of indices).
*/
- IndexSet operator&(const IndexSet &is) const;
+ IndexSet
+ operator&(const IndexSet &is) const;
/**
* This command takes an interval <tt>[begin, end)</tt> and returns the
/**
* Dereferencing operator, returns an IntervalAccessor.
*/
- const IntervalAccessor &operator*() const;
+ const IntervalAccessor &
+ operator*() const;
/**
* Dereferencing operator, returns a pointer to an IntervalAccessor.
*/
- const IntervalAccessor *operator->() const;
+ const IntervalAccessor *
+ operator->() const;
/**
* Comparison.
* Dereferencing operator. The returned value is the index of the element
* inside the IndexSet.
*/
- size_type operator*() const;
+ size_type
+ operator*() const;
/**
* Does this iterator point to an existing element?
inline bool
-IndexSet::IntervalAccessor::
-operator==(const IndexSet::IntervalAccessor &other) const
+IndexSet::IntervalAccessor::operator==(
+ const IndexSet::IntervalAccessor &other) const
{
Assert(index_set == other.index_set,
ExcMessage(
inline bool
-IndexSet::IntervalAccessor::
-operator<(const IndexSet::IntervalAccessor &other) const
+IndexSet::IntervalAccessor::operator<(
+ const IndexSet::IntervalAccessor &other) const
{
Assert(index_set == other.index_set,
ExcMessage(
-inline const IndexSet::IntervalAccessor &IndexSet::IntervalIterator::
- operator*() const
+inline const IndexSet::IntervalAccessor &
+IndexSet::IntervalIterator::operator*() const
{
return accessor;
}
-inline const IndexSet::IntervalAccessor *IndexSet::IntervalIterator::
- operator->() const
+inline const IndexSet::IntervalAccessor *
+IndexSet::IntervalIterator::operator->() const
{
return &accessor;
}
inline bool
-IndexSet::IntervalIterator::
-operator==(const IndexSet::IntervalIterator &other) const
+IndexSet::IntervalIterator::operator==(
+ const IndexSet::IntervalIterator &other) const
{
return accessor == other.accessor;
}
inline bool
-IndexSet::IntervalIterator::
-operator!=(const IndexSet::IntervalIterator &other) const
+IndexSet::IntervalIterator::operator!=(
+ const IndexSet::IntervalIterator &other) const
{
return !(*this == other);
}
inline bool
-IndexSet::IntervalIterator::
-operator<(const IndexSet::IntervalIterator &other) const
+IndexSet::IntervalIterator::operator<(
+ const IndexSet::IntervalIterator &other) const
{
return accessor < other.accessor;
}
inline int
-IndexSet::IntervalIterator::
-operator-(const IndexSet::IntervalIterator &other) const
+IndexSet::IntervalIterator::operator-(
+ const IndexSet::IntervalIterator &other) const
{
Assert(accessor.index_set == other.accessor.index_set,
ExcMessage(
-inline IndexSet::size_type IndexSet::ElementIterator::operator*() const
+inline IndexSet::size_type
+IndexSet::ElementIterator::operator*() const
{
Assert(
is_valid(),
inline bool
-IndexSet::ElementIterator::
-operator==(const IndexSet::ElementIterator &other) const
+IndexSet::ElementIterator::operator==(
+ const IndexSet::ElementIterator &other) const
{
Assert(index_set == other.index_set,
ExcMessage(
inline bool
-IndexSet::ElementIterator::
-operator!=(const IndexSet::ElementIterator &other) const
+IndexSet::ElementIterator::operator!=(
+ const IndexSet::ElementIterator &other) const
{
return !(*this == other);
}
inline bool
-IndexSet::ElementIterator::
-operator<(const IndexSet::ElementIterator &other) const
+IndexSet::ElementIterator::operator<(
+ const IndexSet::ElementIterator &other) const
{
Assert(index_set == other.index_set,
ExcMessage(
inline std::ptrdiff_t
-IndexSet::ElementIterator::
-operator-(const IndexSet::ElementIterator &other) const
+IndexSet::ElementIterator::operator-(
+ const IndexSet::ElementIterator &other) const
{
Assert(index_set == other.index_set,
ExcMessage(
* Dereferencing operator.
* @return The iterator within the collection currently pointed to.
*/
- const BaseIterator &operator*() const;
+ const BaseIterator &
+ operator*() const;
/**
* Dereferencing operator.
* @return The iterator within the collection currently pointed to.
*/
- const BaseIterator *operator->() const;
+ const BaseIterator *
+ operator->() const;
/**
* Prefix increment operator. Move the current iterator to the next
template <typename Iterator>
inline const typename IteratorOverIterators<Iterator>::BaseIterator &
- IteratorOverIterators<Iterator>::operator*() const
+IteratorOverIterators<Iterator>::operator*() const
{
return element_of_iterator_collection;
}
template <typename Iterator>
inline const typename IteratorOverIterators<Iterator>::BaseIterator *
- IteratorOverIterators<Iterator>::operator->() const
+IteratorOverIterators<Iterator>::operator->() const
{
return &element_of_iterator_collection;
}
template <typename Iterator>
inline bool
-IteratorOverIterators<Iterator>::
-operator!=(const IteratorOverIterators &i_o_i) const
+IteratorOverIterators<Iterator>::operator!=(
+ const IteratorOverIterators &i_o_i) const
{
return element_of_iterator_collection != i_o_i.element_of_iterator_collection;
}
/**
* Dereferencing operator.
*/
- reference operator*() const;
+ reference
+ operator*() const;
/**
* Dereferencing operator.
*/
- pointer operator->() const;
+ pointer
+ operator->() const;
/**
* Comparison operator. Returns <code>true</code> if both iterators point to
template <class DerivedIterator, class AccessorType>
inline DerivedIterator &
-LinearIndexIterator<DerivedIterator, AccessorType>::
-operator=(const DerivedIterator &it)
+LinearIndexIterator<DerivedIterator, AccessorType>::operator=(
+ const DerivedIterator &it)
{
accessor.container = it.container;
accessor.linear_index = it.linear_index;
template <class DerivedIterator, class AccessorType>
inline DerivedIterator
-LinearIndexIterator<DerivedIterator, AccessorType>::
-operator+(const difference_type n) const
+LinearIndexIterator<DerivedIterator, AccessorType>::operator+(
+ const difference_type n) const
{
DerivedIterator copy(this->accessor);
copy += n;
template <class DerivedIterator, class AccessorType>
inline DerivedIterator
-LinearIndexIterator<DerivedIterator, AccessorType>::
-operator-(const difference_type n) const
+LinearIndexIterator<DerivedIterator, AccessorType>::operator-(
+ const difference_type n) const
{
DerivedIterator copy(this->accessor);
copy += -n;
template <class DerivedIterator, class AccessorType>
inline DerivedIterator &
-LinearIndexIterator<DerivedIterator, AccessorType>::
-operator+=(const difference_type n)
+LinearIndexIterator<DerivedIterator, AccessorType>::operator+=(
+ const difference_type n)
{
accessor.linear_index += n;
return static_cast<DerivedIterator &>(*this);
template <class DerivedIterator, class AccessorType>
inline DerivedIterator &
-LinearIndexIterator<DerivedIterator, AccessorType>::
-operator-=(const difference_type n)
+LinearIndexIterator<DerivedIterator, AccessorType>::operator-=(
+ const difference_type n)
{
return operator+=(-n);
}
template <class DerivedIterator, class AccessorType>
inline
typename LinearIndexIterator<DerivedIterator, AccessorType>::difference_type
- LinearIndexIterator<DerivedIterator, AccessorType>::
- operator-(const DerivedIterator &other) const
+ LinearIndexIterator<DerivedIterator, AccessorType>::operator-(
+ const DerivedIterator &other) const
{
Assert(this->accessor.container == other.accessor.container,
ExcMessage(
template <class DerivedIterator, class AccessorType>
inline typename LinearIndexIterator<DerivedIterator, AccessorType>::reference
- LinearIndexIterator<DerivedIterator, AccessorType>::operator*() const
+LinearIndexIterator<DerivedIterator, AccessorType>::operator*() const
{
return accessor;
}
template <class DerivedIterator, class AccessorType>
inline typename LinearIndexIterator<DerivedIterator, AccessorType>::pointer
- LinearIndexIterator<DerivedIterator, AccessorType>::operator->() const
+LinearIndexIterator<DerivedIterator, AccessorType>::operator->() const
{
return &accessor;
}
template <class DerivedIterator, class AccessorType>
inline bool
-LinearIndexIterator<DerivedIterator, AccessorType>::
-operator<=(const DerivedIterator &other) const
+LinearIndexIterator<DerivedIterator, AccessorType>::operator<=(
+ const DerivedIterator &other) const
{
return (*this == other) || (*this < other);
}
template <class DerivedIterator, class AccessorType>
inline bool
-LinearIndexIterator<DerivedIterator, AccessorType>::
-operator>=(const DerivedIterator &other) const
+LinearIndexIterator<DerivedIterator, AccessorType>::operator>=(
+ const DerivedIterator &other) const
{
return !(*this < other);
}
template <class DerivedIterator, class AccessorType>
inline bool
-LinearIndexIterator<DerivedIterator, AccessorType>::
-operator<(const DerivedIterator &other) const
+LinearIndexIterator<DerivedIterator, AccessorType>::operator<(
+ const DerivedIterator &other) const
{
Assert(this->accessor.container == other.accessor.container,
ExcMessage(
template <class DerivedIterator, class AccessorType>
inline bool
-LinearIndexIterator<DerivedIterator, AccessorType>::
-operator>(const DerivedIterator &other) const
+LinearIndexIterator<DerivedIterator, AccessorType>::operator>(
+ const DerivedIterator &other) const
{
return other < static_cast<const DerivedIterator &>(*this);
}
template <class... Args>
MGLevelObject(const unsigned int minlevel,
const unsigned int maxlevel,
- Args &&... args);
+ Args &&...args);
/**
* Constructor. Same as above but without arguments to be forwarded to the
/**
* Access object on level @p level.
*/
- Object &operator[](const unsigned int level);
+ Object &
+ operator[](const unsigned int level);
/**
* Access object on level @p level.
* This function can be called on a @p const object, and
* consequently returns a @p const reference.
*/
- const Object &operator[](const unsigned int level) const;
+ const Object &
+ operator[](const unsigned int level) const;
/**
* Delete all previous contents of this object and reset its size according
void
resize(const unsigned int new_minlevel,
const unsigned int new_maxlevel,
- Args &&... args);
+ Args &&...args);
/**
* Call <tt>operator = (s)</tt> on all objects stored by this object.
template <class... Args>
MGLevelObject<Object>::MGLevelObject(const unsigned int min,
const unsigned int max,
- Args &&... args)
+ Args &&...args)
: minlevel(0)
{
resize(min, max, std::forward<Args>(args)...);
template <class Object>
-Object &MGLevelObject<Object>::operator[](const unsigned int i)
+Object &
+MGLevelObject<Object>::operator[](const unsigned int i)
{
Assert((i >= minlevel) && (i < minlevel + objects.size()),
ExcIndexRange(i, minlevel, minlevel + objects.size()));
template <class Object>
-const Object &MGLevelObject<Object>::operator[](const unsigned int i) const
+const Object &
+MGLevelObject<Object>::operator[](const unsigned int i) const
{
Assert((i >= minlevel) && (i < minlevel + objects.size()),
ExcIndexRange(i, minlevel, minlevel + objects.size()));
void
MGLevelObject<Object>::resize(const unsigned int new_minlevel,
const unsigned int new_maxlevel,
- Args &&... args)
+ Args &&...args)
{
Assert(new_minlevel <= new_maxlevel, ExcInternalError());
// note that on clear(), the
/**
* Access the stored communicator.
*/
- const MPI_Comm &operator*() const
+ const MPI_Comm &
+ operator*() const
{
return comm;
}
// ranks. Here, we process the interval by breaking into
// smaller pieces in terms of the dictionary number.
std::pair<types::global_dof_index, types::global_dof_index>
- index_range(*interval->begin(), interval->last() + 1);
+ index_range(*interval->begin(), interval->last() + 1);
const unsigned int owner_last =
dof_to_dict_rank(interval->last());
unsigned int owner_first = numbers::invalid_unsigned_int;
* each arguments separately.
*/
template <class FunctionType>
- MutableBind(FunctionType function, FunctionArgs &&... arguments);
+ MutableBind(FunctionType function, FunctionArgs &&...arguments);
/**
* Construct a MutableBind object specifying the function, and
* operator()() is called, using move semantic.
*/
void
- set_arguments(FunctionArgs &&... arguments);
+ set_arguments(FunctionArgs &&...arguments);
/**
* Parse the arguments to use in @p function from a string, for next time
template <typename ReturnType, class... FunctionArgs>
MutableBind<ReturnType, FunctionArgs...>
mutable_bind(ReturnType (*function)(FunctionArgs...),
- typename identity<FunctionArgs>::type &&... arguments);
+ typename identity<FunctionArgs>::type &&...arguments);
/**
* Same as above, using a std::function object.
template <typename ReturnType, class... FunctionArgs>
MutableBind<ReturnType, FunctionArgs...>
mutable_bind(std::function<ReturnType(FunctionArgs...)>,
- typename identity<FunctionArgs>::type &&... arguments);
+ typename identity<FunctionArgs>::type &&...arguments);
/**
* Create a MutableBind object from a function pointer, with uninitialized
template <class FunctionType>
MutableBind<ReturnType, FunctionArgs...>::MutableBind(
FunctionType function,
- FunctionArgs &&... arguments)
+ FunctionArgs &&...arguments)
: function(function)
, arguments(std::make_tuple(std::move(arguments)...))
{}
template <typename ReturnType, class... FunctionArgs>
void
MutableBind<ReturnType, FunctionArgs...>::set_arguments(
- FunctionArgs &&... args)
+ FunctionArgs &&...args)
{
arguments = std::make_tuple(std::move(args)...);
}
template <typename ReturnType, class... FunctionArgs>
MutableBind<ReturnType, FunctionArgs...>
mutable_bind(ReturnType (*function)(FunctionArgs...),
- typename identity<FunctionArgs>::type &&... arguments)
+ typename identity<FunctionArgs>::type &&...arguments)
{
return MutableBind<ReturnType, FunctionArgs...>(function,
std::move(arguments)...);
template <typename ReturnType, class... FunctionArgs>
MutableBind<ReturnType, FunctionArgs...>
mutable_bind(std::function<ReturnType(FunctionArgs...)> function,
- typename identity<FunctionArgs>::type &&... arguments)
+ typename identity<FunctionArgs>::type &&...arguments)
{
return MutableBind<ReturnType, FunctionArgs...>(function,
std::move(arguments)...);
template <typename number>
constexpr DEAL_II_CUDA_HOST_DEV const number &
- NumberTraits<number>::conjugate(const number &x)
+ NumberTraits<number>::conjugate(const number &x)
{
return x;
}
struct NumberType
{
static constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV const T &
- value(const T &t)
+ value(const T &t)
{
return t;
}
// Type T is constructible from F.
template <typename F>
static constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV T
- value(const F &f,
- typename std::enable_if<
+ value(const F &f,
+ typename std::enable_if<
!std::is_same<typename std::decay<T>::type,
typename std::decay<F>::type>::value &&
std::is_constructible<T, F>::value>::type * = nullptr)
// Type T is explicitly convertible (but not constructible) from F.
template <typename F>
static constexpr DEAL_II_ALWAYS_INLINE T
- value(const F &f,
- typename std::enable_if<
+ value(const F &f,
+ typename std::enable_if<
!std::is_same<typename std::decay<T>::type,
typename std::decay<F>::type>::value &&
!std::is_constructible<T, F>::value &&
f(begin, end);
#else
- internal::parallel_for(begin,
- end,
- [&f](const tbb::blocked_range<RangeType> &range) {
- internal::apply_to_subranges<RangeType, Function>(
- range, f);
- },
- grainsize);
+ internal::parallel_for(
+ begin,
+ end,
+ [&f](const tbb::blocked_range<RangeType> &range) {
+ internal::apply_to_subranges<RangeType, Function>(range, f);
+ },
+ grainsize);
#endif
}
initialize(const std::string &filename = "",
const std::string &output_filename = "",
const ParameterHandler::OutputStyle
- output_style_for_output_filename = ParameterHandler::Short,
+ output_style_for_output_filename = ParameterHandler::Short,
ParameterHandler & prm = ParameterAcceptor::prm,
const ParameterHandler::OutputStyle output_style_for_filename =
ParameterHandler::DefaultStyle);
* @param patterns The list of patterns to use
*/
template <class... PatternTypes>
- Tuple(const std::string &separator, const PatternTypes &... patterns);
+ Tuple(const std::string &separator, const PatternTypes &...patterns);
/**
* Constructor. This is needed to allow users to specify
* specialization, the compiler will fail with cryptic errors.
*/
template <class... PatternTypes>
- Tuple(const char *separator, const PatternTypes &... patterns);
+ Tuple(const char *separator, const PatternTypes &...patterns);
/**
* Constructor. Same as above, using the default separator.
* @param patterns The list of patterns to use
*/
template <typename... Patterns>
- Tuple(const Patterns &... patterns);
+ Tuple(const Patterns &...patterns);
/**
* Copy constructor.
namespace Patterns
{
template <class... PatternTypes>
- Tuple::Tuple(const char *separator, const PatternTypes &... ps)
+ Tuple::Tuple(const char *separator, const PatternTypes &...ps)
: // forward to the version with std::string argument
Tuple(std::string(separator), ps...)
{}
template <class... PatternTypes>
- Tuple::Tuple(const std::string &separator, const PatternTypes &... ps)
+ Tuple::Tuple(const std::string &separator, const PatternTypes &...ps)
: separator(separator)
{
static_assert(is_base_of_all<PatternBase, PatternTypes...>::value,
template <class... PatternTypes>
- Tuple::Tuple(const PatternTypes &... ps)
+ Tuple::Tuple(const PatternTypes &...ps)
: // forward to the version with the separator argument
Tuple(std::string(":"), ps...)
{}
* @note This function can also be used in CUDA device code.
*/
DEAL_II_CUDA_HOST_DEV Number
- operator()(const unsigned int index) const;
+ operator()(const unsigned int index) const;
/**
* Read and write access to the <tt>index</tt>th coordinate.
*
* @note This function can also be used in CUDA device code.
*/
- DEAL_II_CUDA_HOST_DEV Number operator*(const Tensor<1, dim, Number> &p) const;
+ DEAL_II_CUDA_HOST_DEV Number
+ operator*(const Tensor<1, dim, Number> &p) const;
/**
* Return the scalar product of this point vector with itself, i.e. the
template <int dim, typename Number>
template <typename OtherNumber>
inline DEAL_II_CUDA_HOST_DEV
- Point<dim,
+ Point<dim,
typename ProductType<Number,
typename EnableIfScalar<OtherNumber>::type>::type>
- Point<dim, Number>::operator*(const OtherNumber factor) const
+ Point<dim, Number>::operator*(const OtherNumber factor) const
{
Point<dim, typename ProductType<Number, OtherNumber>::type> tmp;
for (unsigned int i = 0; i < dim; ++i)
template <int dim, typename Number>
-inline DEAL_II_CUDA_HOST_DEV Number Point<dim, Number>::
- operator*(const Tensor<1, dim, Number> &p) const
+inline DEAL_II_CUDA_HOST_DEV Number
+Point<dim, Number>::operator*(const Tensor<1, dim, Number> &p) const
{
Number res = Number();
for (unsigned int i = 0; i < dim; ++i)
* Multiply by a scalar.
*/
template <typename Number2>
- BarycentricPolynomial<dim, Number> operator*(const Number2 &a) const;
+ BarycentricPolynomial<dim, Number>
+ operator*(const Number2 &a) const;
/**
* Divide by a scalar.
/**
* Access operator.
*/
- const BarycentricPolynomial<dim> &operator[](const std::size_t i) const;
+ const BarycentricPolynomial<dim> &
+ operator[](const std::size_t i) const;
/**
* @copydoc ScalarPolynomialsBase::evaluate()
template <int dim, typename Number>
template <typename Number2>
-BarycentricPolynomial<dim, Number> BarycentricPolynomial<dim, Number>::
- operator*(const Number2 &a) const
+BarycentricPolynomial<dim, Number>
+BarycentricPolynomial<dim, Number>::operator*(const Number2 &a) const
{
if (a == Number2())
{
template <int dim, typename Number>
BarycentricPolynomial<dim, Number>
-BarycentricPolynomial<dim, Number>::
-operator+(const BarycentricPolynomial<dim, Number> &augend) const
+BarycentricPolynomial<dim, Number>::operator+(
+ const BarycentricPolynomial<dim, Number> &augend) const
{
TableIndices<dim + 1> deg;
for (unsigned int d = 0; d < dim + 1; ++d)
template <int dim, typename Number>
BarycentricPolynomial<dim, Number>
-BarycentricPolynomial<dim, Number>::
-operator-(const BarycentricPolynomial<dim, Number> &augend) const
+BarycentricPolynomial<dim, Number>::operator-(
+ const BarycentricPolynomial<dim, Number> &augend) const
{
return *this + (-augend);
}
template <int dim, typename Number>
-BarycentricPolynomial<dim, Number> BarycentricPolynomial<dim, Number>::
- operator*(const BarycentricPolynomial<dim, Number> &multiplicand) const
+BarycentricPolynomial<dim, Number>
+BarycentricPolynomial<dim, Number>::operator*(
+ const BarycentricPolynomial<dim, Number> &multiplicand) const
{
TableIndices<dim + 1> deg;
for (unsigned int d = 0; d < dim + 1; ++d)
}
template <int dim>
-const BarycentricPolynomial<dim> &BarycentricPolynomials<dim>::
- operator[](const std::size_t i) const
+const BarycentricPolynomial<dim> &
+BarycentricPolynomials<dim>::operator[](const std::size_t i) const
{
AssertIndexRange(i, polys.size());
return polys[i];
* Dereferencing operator. This operator throws an ExcNotInitialized() if the
* pointer is a null pointer.
*/
- T &operator*() const;
+ T &
+ operator*() const;
/**
* Dereferencing operator. This operator throws an ExcNotInitializedi() if the
* pointer is a null pointer.
*/
- T *operator->() const;
+ T *
+ operator->() const;
/**
* Exchange the pointers of this object and the argument. Since both the
template <typename T, typename P>
-inline T &SmartPointer<T, P>::operator*() const
+inline T &
+SmartPointer<T, P>::operator*() const
{
Assert(t != nullptr, ExcNotInitialized());
Assert(pointed_to_object_is_alive,
template <typename T, typename P>
-inline T *SmartPointer<T, P>::operator->() const
+inline T *
+SmartPointer<T, P>::operator->() const
{
Assert(t != nullptr, ExcNotInitialized());
Assert(pointed_to_object_is_alive,
template <int dim2, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Number
- trace(const SymmetricTensor<2, dim2, Number> &);
+trace(const SymmetricTensor<2, dim2, Number> &);
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
- deviator(const SymmetricTensor<2, dim, Number> &);
+deviator(const SymmetricTensor<2, dim, Number> &);
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Number
- determinant(const SymmetricTensor<2, dim, Number> &);
+determinant(const SymmetricTensor<2, dim, Number> &);
* invalid state.
*/
DEAL_II_CONSTEXPR inline DEAL_II_ALWAYS_INLINE TableIndices<2>
- merge(const TableIndices<2> &previous_indices,
- const unsigned int new_index,
- const unsigned int position)
+ merge(const TableIndices<2> &previous_indices,
+ const unsigned int new_index,
+ const unsigned int position)
{
AssertIndexRange(position, 2);
* invalid state.
*/
DEAL_II_CONSTEXPR inline DEAL_II_ALWAYS_INLINE TableIndices<4>
- merge(const TableIndices<4> &previous_indices,
- const unsigned int new_index,
- const unsigned int position)
+ merge(const TableIndices<4> &previous_indices,
+ const unsigned int new_index,
+ const unsigned int position)
{
AssertIndexRange(position, 4);
/**
* Index operator.
*/
- constexpr reference operator[](const unsigned int);
+ constexpr reference
+ operator[](const unsigned int);
/**
* Index operator.
*/
- constexpr reference operator[](const unsigned int) const;
+ constexpr reference
+ operator[](const unsigned int) const;
private:
/**
*
* Exactly the same as operator().
*/
- constexpr const Number &operator[](const TableIndices<rank_> &indices) const;
+ constexpr const Number &
+ operator[](const TableIndices<rank_> &indices) const;
/**
* Return a read-write reference to the indicated element.
*
* Exactly the same as operator().
*/
- constexpr Number &operator[](const TableIndices<rank_> &indices);
+ constexpr Number &
+ operator[](const TableIndices<rank_> &indices);
/**
* Access to an element according to unrolled index. The function
template <int rank_, int dim, bool constness, int P, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE
- Accessor<rank_, dim, constness, P - 1, Number>
- Accessor<rank_, dim, constness, P, Number>::
- operator[](const unsigned int i)
+ Accessor<rank_, dim, constness, P - 1, Number>
+ Accessor<rank_, dim, constness, P, Number>::operator[](
+ const unsigned int i)
{
return Accessor<rank_, dim, constness, P - 1, Number>(
tensor, merge(previous_indices, i, rank_ - P));
template <int rank_, int dim, bool constness, int P, typename Number>
constexpr DEAL_II_ALWAYS_INLINE
- Accessor<rank_, dim, constness, P - 1, Number>
- Accessor<rank_, dim, constness, P, Number>::
- operator[](const unsigned int i) const
+ Accessor<rank_, dim, constness, P - 1, Number>
+ Accessor<rank_, dim, constness, P, Number>::operator[](
+ const unsigned int i) const
{
return Accessor<rank_, dim, constness, P - 1, Number>(
tensor, merge(previous_indices, i, rank_ - P));
template <int rank_, int dim, bool constness, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE
typename Accessor<rank_, dim, constness, 1, Number>::reference
- Accessor<rank_, dim, constness, 1, Number>::
- operator[](const unsigned int i)
+ Accessor<rank_, dim, constness, 1, Number>::operator[](
+ const unsigned int i)
{
return tensor(merge(previous_indices, i, rank_ - 1));
}
template <int rank_, int dim, bool constness, typename Number>
constexpr DEAL_II_ALWAYS_INLINE
typename Accessor<rank_, dim, constness, 1, Number>::reference
- Accessor<rank_, dim, constness, 1, Number>::
- operator[](const unsigned int i) const
+ Accessor<rank_, dim, constness, 1, Number>::operator[](
+ const unsigned int i) const
{
return tensor(merge(previous_indices, i, rank_ - 1));
}
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE SymmetricTensor<rank_, dim, Number> &
- SymmetricTensor<rank_, dim, Number>::
- operator=(const SymmetricTensor<rank_, dim, OtherNumber> &t)
+SymmetricTensor<rank_, dim, Number>::operator=(
+ const SymmetricTensor<rank_, dim, OtherNumber> &t)
{
data = t.data;
return *this;
{
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE dealii::Tensor<2, dim, Number>
- convert_to_tensor(const dealii::SymmetricTensor<2, dim, Number> &s)
+ convert_to_tensor(const dealii::SymmetricTensor<2, dim, Number> &s)
{
dealii::Tensor<2, dim, Number> t;
template <int rank_, int dim, typename Number>
-constexpr DEAL_II_ALWAYS_INLINE SymmetricTensor<rank_, dim, Number>::
- operator Tensor<rank_, dim, Number>() const
+constexpr DEAL_II_ALWAYS_INLINE
+ SymmetricTensor<rank_, dim, Number>::operator Tensor<rank_, dim, Number>()
+ const
{
return internal::SymmetricTensorImplementation::convert_to_tensor(*this);
}
template <int rank_, int dim, typename Number>
constexpr bool
-SymmetricTensor<rank_, dim, Number>::
-operator==(const SymmetricTensor<rank_, dim, Number> &t) const
+SymmetricTensor<rank_, dim, Number>::operator==(
+ const SymmetricTensor<rank_, dim, Number> &t) const
{
return data == t.data;
}
template <int rank_, int dim, typename Number>
constexpr bool
-SymmetricTensor<rank_, dim, Number>::
-operator!=(const SymmetricTensor<rank_, dim, Number> &t) const
+SymmetricTensor<rank_, dim, Number>::operator!=(
+ const SymmetricTensor<rank_, dim, Number> &t) const
{
return data != t.data;
}
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE SymmetricTensor<rank_, dim, Number> &
- SymmetricTensor<rank_, dim, Number>::
- operator+=(const SymmetricTensor<rank_, dim, OtherNumber> &t)
+SymmetricTensor<rank_, dim, Number>::operator+=(
+ const SymmetricTensor<rank_, dim, OtherNumber> &t)
{
data += t.data;
return *this;
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE SymmetricTensor<rank_, dim, Number> &
- SymmetricTensor<rank_, dim, Number>::
- operator-=(const SymmetricTensor<rank_, dim, OtherNumber> &t)
+SymmetricTensor<rank_, dim, Number>::operator-=(
+ const SymmetricTensor<rank_, dim, OtherNumber> &t)
{
data -= t.data;
return *this;
DEAL_II_CONSTEXPR inline DEAL_II_ALWAYS_INLINE
typename internal::SymmetricTensorAccessors::
double_contraction_result<rank_, 2, dim, Number, OtherNumber>::type
- SymmetricTensor<rank_, dim, Number>::
- operator*(const SymmetricTensor<2, dim, OtherNumber> &s) const
+ SymmetricTensor<rank_, dim, Number>::operator*(
+ const SymmetricTensor<2, dim, OtherNumber> &s) const
{
// need to have two different function calls
// because a scalar and rank-2 tensor are not
template <typename OtherNumber>
DEAL_II_CONSTEXPR inline typename internal::SymmetricTensorAccessors::
double_contraction_result<rank_, 4, dim, Number, OtherNumber>::type
- SymmetricTensor<rank_, dim, Number>::
- operator*(const SymmetricTensor<4, dim, OtherNumber> &s) const
+ SymmetricTensor<rank_, dim, Number>::operator*(
+ const SymmetricTensor<4, dim, OtherNumber> &s) const
{
typename internal::SymmetricTensorAccessors::
double_contraction_result<rank_, 4, dim, Number, OtherNumber>::type tmp;
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Number &
- symmetric_tensor_access(const TableIndices<2> &indices,
- typename SymmetricTensorAccessors::
- StorageType<2, dim, Number>::base_tensor_type &data)
+ symmetric_tensor_access(const TableIndices<2> &indices,
+ typename SymmetricTensorAccessors::
+ StorageType<2, dim, Number>::base_tensor_type &data)
{
// 1d is very simple and done first
if (dim == 1)
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE const Number &
- symmetric_tensor_access(const TableIndices<2> &indices,
- const typename SymmetricTensorAccessors::
- StorageType<2, dim, Number>::base_tensor_type &data)
+ symmetric_tensor_access(const TableIndices<2> &indices,
+ const typename SymmetricTensorAccessors::
+ StorageType<2, dim, Number>::base_tensor_type &data)
{
// 1d is very simple and done first
if (dim == 1)
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE const Number &
- symmetric_tensor_access(const TableIndices<4> &indices,
- const typename SymmetricTensorAccessors::
- StorageType<4, dim, Number>::base_tensor_type &data)
+ symmetric_tensor_access(const TableIndices<4> &indices,
+ const typename SymmetricTensorAccessors::
+ StorageType<4, dim, Number>::base_tensor_type &data)
{
switch (dim)
{
template <int rank_, int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Number &
- SymmetricTensor<rank_, dim, Number>::
- operator()(const TableIndices<rank_> &indices)
+SymmetricTensor<rank_, dim, Number>::operator()(
+ const TableIndices<rank_> &indices)
{
for (unsigned int r = 0; r < rank; ++r)
AssertIndexRange(indices[r], dimension);
template <int rank_, int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE const Number &
- SymmetricTensor<rank_, dim, Number>::
- operator()(const TableIndices<rank_> &indices) const
+SymmetricTensor<rank_, dim, Number>::operator()(
+ const TableIndices<rank_> &indices) const
{
for (unsigned int r = 0; r < rank; ++r)
AssertIndexRange(indices[r], dimension);
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE internal::SymmetricTensorAccessors::
Accessor<rank_, dim, true, rank_ - 1, Number>
- SymmetricTensor<rank_, dim, Number>::
- operator[](const unsigned int row) const
+ SymmetricTensor<rank_, dim, Number>::operator[](const unsigned int row) const
{
return internal::SymmetricTensorAccessors::
Accessor<rank_, dim, true, rank_ - 1, Number>(
template <int rank_, int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE internal::SymmetricTensorAccessors::
Accessor<rank_, dim, false, rank_ - 1, Number>
- SymmetricTensor<rank_, dim, Number>::operator[](const unsigned int row)
+ SymmetricTensor<rank_, dim, Number>::operator[](const unsigned int row)
{
return internal::SymmetricTensorAccessors::
Accessor<rank_, dim, false, rank_ - 1, Number>(
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE const Number &
- SymmetricTensor<rank_, dim, Number>::
- operator[](const TableIndices<rank_> &indices) const
+SymmetricTensor<rank_, dim, Number>::operator[](
+ const TableIndices<rank_> &indices) const
{
return operator()(indices);
}
template <int rank_, int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Number &
- SymmetricTensor<rank_, dim, Number>::
- operator[](const TableIndices<rank_> &indices)
+SymmetricTensor<rank_, dim, Number>::operator[](
+ const TableIndices<rank_> &indices)
{
return operator()(indices);
}
// this function is for rank-2 tensors
template <int dim>
constexpr inline DEAL_II_ALWAYS_INLINE TableIndices<2>
- unrolled_to_component_indices(const unsigned int i,
- const std::integral_constant<int, 2> &)
+ unrolled_to_component_indices(const unsigned int i,
+ const std::integral_constant<int, 2> &)
{
Assert(
(i < dealii::SymmetricTensor<2, dim, double>::n_independent_components),
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE TableIndices<rank_>
- SymmetricTensor<rank_, dim, Number>::unrolled_to_component_indices(
+SymmetricTensor<rank_, dim, Number>::unrolled_to_component_indices(
const unsigned int i)
{
return internal::SymmetricTensorImplementation::unrolled_to_component_indices<
*/
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Number
- determinant(const SymmetricTensor<2, dim, Number> &t)
+determinant(const SymmetricTensor<2, dim, Number> &t)
{
switch (dim)
{
*/
template <int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE Number
- third_invariant(const SymmetricTensor<2, dim, Number> &t)
+third_invariant(const SymmetricTensor<2, dim, Number> &t)
{
return determinant(t);
}
*/
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Number
- trace(const SymmetricTensor<2, dim, Number> &d)
+trace(const SymmetricTensor<2, dim, Number> &d)
{
Number t = d.data[0];
for (unsigned int i = 1; i < dim; ++i)
*/
template <typename Number>
constexpr DEAL_II_ALWAYS_INLINE Number
- second_invariant(const SymmetricTensor<2, 1, Number> &)
+second_invariant(const SymmetricTensor<2, 1, Number> &)
{
return internal::NumberType<Number>::value(0.0);
}
*/
template <typename Number>
constexpr DEAL_II_ALWAYS_INLINE Number
- second_invariant(const SymmetricTensor<2, 2, Number> &t)
+second_invariant(const SymmetricTensor<2, 2, Number> &t)
{
return t[0][0] * t[1][1] - t[0][1] * t[0][1];
}
*/
template <typename Number>
constexpr DEAL_II_ALWAYS_INLINE Number
- second_invariant(const SymmetricTensor<2, 3, Number> &t)
+second_invariant(const SymmetricTensor<2, 3, Number> &t)
{
return (t[0][0] * t[1][1] + t[1][1] * t[2][2] + t[2][2] * t[0][0] -
t[0][1] * t[0][1] - t[0][2] * t[0][2] - t[1][2] * t[1][2]);
*/
template <int dim, typename Number>
std::array<std::pair<Number, Tensor<1, dim, Number>>, dim>
- jacobi(dealii::SymmetricTensor<2, dim, Number> A);
+ jacobi(dealii::SymmetricTensor<2, dim, Number> A);
*/
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE SymmetricTensor<rank_, dim, Number>
- transpose(const SymmetricTensor<rank_, dim, Number> &t)
+transpose(const SymmetricTensor<rank_, dim, Number> &t)
{
return t;
}
*/
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
- deviator(const SymmetricTensor<2, dim, Number> &t)
+deviator(const SymmetricTensor<2, dim, Number> &t)
{
SymmetricTensor<2, dim, Number> tmp = t;
*/
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
- symmetrize(const Tensor<2, dim, Number> &t)
+symmetrize(const Tensor<2, dim, Number> &t)
{
SymmetricTensor<2, dim, Number> result;
for (unsigned int d = 0; d < dim; ++d)
*/
template <int rank_, int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE SymmetricTensor<rank_, dim, Number>
- operator*(const SymmetricTensor<rank_, dim, Number> &t, const Number &factor)
+operator*(const SymmetricTensor<rank_, dim, Number> &t, const Number &factor)
{
SymmetricTensor<rank_, dim, Number> tt = t;
tt *= factor;
*/
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE SymmetricTensor<rank_, dim, Number>
- operator*(const Number &factor, const SymmetricTensor<rank_, dim, Number> &t)
+operator*(const Number &factor, const SymmetricTensor<rank_, dim, Number> &t)
{
// simply forward to the other operator
return t * factor;
*/
template <int rank_, int dim>
constexpr inline DEAL_II_ALWAYS_INLINE SymmetricTensor<rank_, dim>
- operator*(const SymmetricTensor<rank_, dim> &t, const double factor)
+operator*(const SymmetricTensor<rank_, dim> &t, const double factor)
{
SymmetricTensor<rank_, dim> tt(t);
tt *= factor;
*/
template <int rank_, int dim>
constexpr inline DEAL_II_ALWAYS_INLINE SymmetricTensor<rank_, dim>
- operator*(const double factor, const SymmetricTensor<rank_, dim> &t)
+operator*(const double factor, const SymmetricTensor<rank_, dim> &t)
{
SymmetricTensor<rank_, dim> tt(t);
tt *= factor;
* @relatesalso SymmetricTensor
*/
template <typename Number, typename OtherNumber>
-constexpr inline DEAL_II_ALWAYS_INLINE void double_contract(
+constexpr inline DEAL_II_ALWAYS_INLINE void
+double_contract(
SymmetricTensor<2, 1, typename ProductType<Number, OtherNumber>::type> &tmp,
const SymmetricTensor<4, 1, Number> & t,
const SymmetricTensor<2, 1, OtherNumber> & s)
* @relatesalso SymmetricTensor
*/
template <typename Number, typename OtherNumber>
-constexpr inline void double_contract(
+constexpr inline void
+double_contract(
SymmetricTensor<2, 1, typename ProductType<Number, OtherNumber>::type> &tmp,
const SymmetricTensor<2, 1, Number> & s,
const SymmetricTensor<4, 1, OtherNumber> & t)
* @relatesalso SymmetricTensor
*/
template <typename Number, typename OtherNumber>
-constexpr inline void double_contract(
+constexpr inline void
+double_contract(
SymmetricTensor<2, 2, typename ProductType<Number, OtherNumber>::type> &tmp,
const SymmetricTensor<4, 2, Number> & t,
const SymmetricTensor<2, 2, OtherNumber> & s)
* @relatesalso SymmetricTensor
*/
template <typename Number, typename OtherNumber>
-constexpr inline void double_contract(
+constexpr inline void
+double_contract(
SymmetricTensor<2, 2, typename ProductType<Number, OtherNumber>::type> &tmp,
const SymmetricTensor<2, 2, Number> & s,
const SymmetricTensor<4, 2, OtherNumber> & t)
* @relatesalso SymmetricTensor
*/
template <typename Number, typename OtherNumber>
-constexpr inline void double_contract(
+constexpr inline void
+double_contract(
SymmetricTensor<2, 3, typename ProductType<Number, OtherNumber>::type> &tmp,
const SymmetricTensor<4, 3, Number> & t,
const SymmetricTensor<2, 3, OtherNumber> & s)
* @relatesalso SymmetricTensor
*/
template <typename Number, typename OtherNumber>
-constexpr inline void double_contract(
+constexpr inline void
+double_contract(
SymmetricTensor<2, 3, typename ProductType<Number, OtherNumber>::type> &tmp,
const SymmetricTensor<2, 3, Number> & s,
const SymmetricTensor<4, 3, OtherNumber> & t)
template <int dim, typename Number>
std::array<std::pair<Number, Tensor<1, dim, Number>>, dim>
- jacobi(dealii::SymmetricTensor<2, dim, Number> A)
+ jacobi(dealii::SymmetricTensor<2, dim, Number> A)
{
static_assert(numbers::NumberTraits<Number>::is_complex == false,
"This implementation of the Jacobi algorithm does "
* Dereference const operator. Returns a const reference to the iterators
* represented by the current class.
*/
- const Iterators &operator*() const;
+ const Iterators &
+ operator*() const;
/**
* Dereference operator. Returns a reference to the iterators
* represented by the current class.
*/
- Iterators &operator*();
+ Iterators &
+ operator*();
private:
/**
template <typename Iterators>
-inline const Iterators &SynchronousIterators<Iterators>::operator*() const
+inline const Iterators &
+SynchronousIterators<Iterators>::operator*() const
{
return iterators;
}
template <typename Iterators>
-inline Iterators &SynchronousIterators<Iterators>::operator*()
+inline Iterators &
+SynchronousIterators<Iterators>::operator*()
{
return iterators;
}
/**
* Index operator. Performs a range check.
*/
- Accessor<N, T, C, P - 1> operator[](const size_type i) const;
+ Accessor<N, T, C, P - 1>
+ operator[](const size_type i) const;
/**
* Exception for range check. Do not use global exception since this way
/**
* Index operator. Performs a range check.
*/
- reference operator[](const size_type) const;
+ reference
+ operator[](const size_type) const;
/**
* Return the length of one row, i.e. the number of elements
* Access operator. Since this is a one-dimensional object, this simply
* accesses the requested data element. Returns a read-write reference.
*/
- typename AlignedVector<T>::reference operator[](const size_type i);
+ typename AlignedVector<T>::reference
+ operator[](const size_type i);
/**
* Access operator. Since this is a one-dimensional object, this simply
template <int N, typename T, bool C, unsigned int P>
- inline Accessor<N, T, C, P - 1> Accessor<N, T, C, P>::
- operator[](const size_type i) const
+ inline Accessor<N, T, C, P - 1>
+ Accessor<N, T, C, P>::operator[](const size_type i) const
{
AssertIndexRange(i, table.size()[N - P]);
template <int N, typename T, bool C>
- inline typename Accessor<N, T, C, 1>::reference Accessor<N, T, C, 1>::
- operator[](const size_type i) const
+ inline typename Accessor<N, T, C, 1>::reference
+ Accessor<N, T, C, 1>::operator[](const size_type i) const
{
AssertIndexRange(i, table.size()[N - 1]);
return *(data + i);
template <typename T>
-inline typename AlignedVector<T>::const_reference Table<1, T>::
- operator[](const size_type i) const
+inline typename AlignedVector<T>::const_reference
+Table<1, T>::operator[](const size_type i) const
{
AssertIndexRange(i, this->table_size[0]);
return this->values[i];
template <typename T>
-inline typename AlignedVector<T>::reference Table<1, T>::
- operator[](const size_type i)
+inline typename AlignedVector<T>::reference
+Table<1, T>::operator[](const size_type i)
{
AssertIndexRange(i, this->table_size[0]);
return this->values[i];
template <typename T>
inline dealii::internal::TableBaseAccessors::Accessor<2, T, true, 1>
- Table<2, T>::operator[](const size_type i) const
+Table<2, T>::operator[](const size_type i) const
{
AssertIndexRange(i, this->table_size[0]);
return dealii::internal::TableBaseAccessors::Accessor<2, T, true, 1>(
template <typename T>
inline dealii::internal::TableBaseAccessors::Accessor<2, T, false, 1>
- Table<2, T>::operator[](const size_type i)
+Table<2, T>::operator[](const size_type i)
{
AssertIndexRange(i, this->table_size[0]);
return dealii::internal::TableBaseAccessors::Accessor<2, T, false, 1>(
template <typename T>
inline dealii::internal::TableBaseAccessors::Accessor<3, T, true, 2>
- Table<3, T>::operator[](const size_type i) const
+Table<3, T>::operator[](const size_type i) const
{
AssertIndexRange(i, this->table_size[0]);
const size_type subobject_size =
template <typename T>
inline dealii::internal::TableBaseAccessors::Accessor<3, T, false, 2>
- Table<3, T>::operator[](const size_type i)
+Table<3, T>::operator[](const size_type i)
{
AssertIndexRange(i, this->table_size[0]);
const size_type subobject_size =
template <typename T>
inline typename AlignedVector<T>::const_reference
-Table<3, T>::
-operator()(const size_type i, const size_type j, const size_type k) const
+Table<3, T>::operator()(const size_type i,
+ const size_type j,
+ const size_type k) const
{
AssertIndexRange(i, this->table_size[0]);
AssertIndexRange(j, this->table_size[1]);
template <typename T>
inline dealii::internal::TableBaseAccessors::Accessor<4, T, true, 3>
- Table<4, T>::operator[](const size_type i) const
+Table<4, T>::operator[](const size_type i) const
{
AssertIndexRange(i, this->table_size[0]);
const size_type subobject_size =
template <typename T>
inline dealii::internal::TableBaseAccessors::Accessor<4, T, false, 3>
- Table<4, T>::operator[](const size_type i)
+Table<4, T>::operator[](const size_type i)
{
AssertIndexRange(i, this->table_size[0]);
const size_type subobject_size =
template <typename T>
inline dealii::internal::TableBaseAccessors::Accessor<5, T, true, 4>
- Table<5, T>::operator[](const size_type i) const
+Table<5, T>::operator[](const size_type i) const
{
AssertIndexRange(i, this->table_size[0]);
const size_type subobject_size = size_type(this->table_size[1]) *
template <typename T>
inline dealii::internal::TableBaseAccessors::Accessor<5, T, false, 4>
- Table<5, T>::operator[](const size_type i)
+Table<5, T>::operator[](const size_type i)
{
AssertIndexRange(i, this->table_size[0]);
const size_type subobject_size = size_type(this->table_size[1]) *
template <typename T>
inline dealii::internal::TableBaseAccessors::Accessor<6, T, true, 5>
- Table<6, T>::operator[](const size_type i) const
+Table<6, T>::operator[](const size_type i) const
{
AssertIndexRange(i, this->table_size[0]);
const size_type subobject_size = size_type(this->table_size[1]) *
template <typename T>
inline dealii::internal::TableBaseAccessors::Accessor<6, T, false, 5>
- Table<6, T>::operator[](const size_type i)
+Table<6, T>::operator[](const size_type i)
{
AssertIndexRange(i, this->table_size[0]);
const size_type subobject_size = size_type(this->table_size[1]) *
template <typename T>
inline dealii::internal::TableBaseAccessors::Accessor<7, T, true, 6>
- Table<7, T>::operator[](const size_type i) const
+Table<7, T>::operator[](const size_type i) const
{
AssertIndexRange(i, this->table_size[0]);
const size_type subobject_size =
template <typename T>
inline dealii::internal::TableBaseAccessors::Accessor<7, T, false, 6>
- Table<7, T>::operator[](const size_type i)
+Table<7, T>::operator[](const size_type i)
{
AssertIndexRange(i, this->table_size[0]);
const size_type subobject_size =
/**
* Read-only access the value of the <tt>i</tt>th index.
*/
- constexpr std::size_t operator[](const unsigned int i) const;
+ constexpr std::size_t
+ operator[](const unsigned int i) const;
/**
* Write access the value of the <tt>i</tt>th index.
*/
- constexpr std::size_t &operator[](const unsigned int i);
+ constexpr std::size_t &
+ operator[](const unsigned int i);
/**
* Compare two index fields for equality.
template <int N>
-constexpr inline std::size_t TableIndices<N>::
- operator[](const unsigned int i) const
+constexpr inline std::size_t
+TableIndices<N>::operator[](const unsigned int i) const
{
AssertIndexRange(i, N);
return indices[i];
template <int N>
-constexpr inline std::size_t &TableIndices<N>::operator[](const unsigned int i)
+constexpr inline std::size_t &
+TableIndices<N>::operator[](const unsigned int i)
{
AssertIndexRange(i, N);
return indices[i];
* Move constructor
*/
constexpr DEAL_II_CUDA_HOST_DEV
- Tensor(Tensor<0, dim, Number> &&other) noexcept;
+ Tensor(Tensor<0, dim, Number> &&other) noexcept;
#endif
/**
*
* @note This function can also be used in CUDA device code.
*/
- constexpr DEAL_II_CUDA_HOST_DEV operator Number &();
+ constexpr DEAL_II_CUDA_HOST_DEV
+ operator Number &();
/**
* Return a reference to the encapsulated Number object. Since rank-0
*/
template <typename OtherNumber>
constexpr DEAL_II_CUDA_HOST_DEV Tensor &
- operator=(const Tensor<0, dim, OtherNumber> &rhs);
+ operator=(const Tensor<0, dim, OtherNumber> &rhs);
#if defined(__INTEL_COMPILER) || defined(DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG)
/**
* Move assignment operator
*/
constexpr DEAL_II_CUDA_HOST_DEV Tensor<0, dim, Number> &
- operator=(Tensor<0, dim, Number> &&other) noexcept;
+ operator=(Tensor<0, dim, Number> &&other) noexcept;
#endif
/**
*/
template <typename OtherNumber>
constexpr DEAL_II_CUDA_HOST_DEV Tensor &
- operator+=(const Tensor<0, dim, OtherNumber> &rhs);
+ operator+=(const Tensor<0, dim, OtherNumber> &rhs);
/**
* Subtract another scalar.
*/
template <typename OtherNumber>
constexpr DEAL_II_CUDA_HOST_DEV Tensor &
- operator-=(const Tensor<0, dim, OtherNumber> &rhs);
+ operator-=(const Tensor<0, dim, OtherNumber> &rhs);
/**
* Multiply the scalar with a <tt>factor</tt>.
* @note This function can also be used in CUDA device code.
*/
constexpr DEAL_II_CUDA_HOST_DEV Tensor
- operator-() const;
+ operator-() const;
/**
* Reset all values to zero.
* @note This function can also be used in CUDA device code.
*/
constexpr DEAL_II_CUDA_HOST_DEV real_type
- norm_square() const;
+ norm_square() const;
/**
* Read or write the data of this object to or from a stream for the purpose
* @note This function can also be used in CUDA device code.
*/
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor();
+ Tensor();
/**
* A constructor where the data is copied from a C-style array.
*
* @note This function can also be used in CUDA device code.
*/
- constexpr DEAL_II_CUDA_HOST_DEV value_type &operator[](const unsigned int i);
+ constexpr DEAL_II_CUDA_HOST_DEV value_type &
+ operator[](const unsigned int i);
/**
* Read-only access operator.
/**
* Read access using TableIndices <tt>indices</tt>
*/
- constexpr const Number &operator[](const TableIndices<rank_> &indices) const;
+ constexpr const Number &
+ operator[](const TableIndices<rank_> &indices) const;
/**
* Read and write access using TableIndices <tt>indices</tt>
*/
- constexpr Number &operator[](const TableIndices<rank_> &indices);
+ constexpr Number &
+ operator[](const TableIndices<rank_> &indices);
/**
* Return a pointer to the first element of the underlying storage.
*/
template <typename OtherNumber>
constexpr DEAL_II_CUDA_HOST_DEV Tensor &
- operator=(const Tensor<rank_, dim, OtherNumber> &rhs);
+ operator=(const Tensor<rank_, dim, OtherNumber> &rhs);
/**
* This operator assigns a scalar to a tensor. To avoid confusion with what
*/
template <typename OtherNumber>
constexpr DEAL_II_CUDA_HOST_DEV Tensor &
- operator+=(const Tensor<rank_, dim, OtherNumber> &);
+ operator+=(const Tensor<rank_, dim, OtherNumber> &);
/**
* Subtract another tensor.
*/
template <typename OtherNumber>
constexpr DEAL_II_CUDA_HOST_DEV Tensor &
- operator-=(const Tensor<rank_, dim, OtherNumber> &);
+ operator-=(const Tensor<rank_, dim, OtherNumber> &);
/**
* Scale the tensor by <tt>factor</tt>, i.e. multiply all components by
* @note This function can also be used in CUDA device code.
*/
constexpr DEAL_II_CUDA_HOST_DEV Tensor
- operator-() const;
+ operator-() const;
/**
* Reset all values to zero.
struct NumberType<Tensor<rank, dim, T>>
{
static constexpr DEAL_II_ALWAYS_INLINE const Tensor<rank, dim, T> &
- value(const Tensor<rank, dim, T> &t)
+ value(const Tensor<rank, dim, T> &t)
{
return t;
}
template <int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor<0, dim, Number>::Tensor()
+Tensor<0, dim, Number>::Tensor()
// Some auto-differentiable numbers need explicit
// zero initialization such as adtl::adouble.
: Tensor{0.0}
template <int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor<0, dim, Number>::Tensor(const OtherNumber &initializer)
+Tensor<0, dim, Number>::Tensor(const OtherNumber &initializer)
: value(internal::NumberType<Number>::value(initializer))
{}
template <int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor<0, dim, Number>::Tensor(const Tensor<0, dim, OtherNumber> &p)
+Tensor<0, dim, Number>::Tensor(const Tensor<0, dim, OtherNumber> &p)
: Tensor{p.value}
{}
# ifdef DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG
template <int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor<0, dim, Number>::Tensor(const Tensor<0, dim, Number> &other)
+Tensor<0, dim, Number>::Tensor(const Tensor<0, dim, Number> &other)
: value{other.value}
{}
template <int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor<0, dim, Number>::Tensor(Tensor<0, dim, Number> &&other) noexcept
+Tensor<0, dim, Number>::Tensor(Tensor<0, dim, Number> &&other) noexcept
: value{std::move(other.value)}
{}
# endif
template <int dim, typename Number>
-constexpr inline DEAL_II_ALWAYS_INLINE
- DEAL_II_CUDA_HOST_DEV Tensor<0, dim, Number>::operator Number &()
+constexpr inline DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
+Tensor<0, dim, Number>::operator Number &()
{
// We cannot use Assert inside a CUDA kernel
# ifndef __CUDA_ARCH__
# ifdef DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG
template <int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV Tensor<0, dim, Number> &
- Tensor<0, dim, Number>::operator=(Tensor<0, dim, Number> &&other) noexcept
+Tensor<0, dim, Number>::operator=(Tensor<0, dim, Number> &&other) noexcept
{
value = std::move(other.value);
return *this;
{
template <typename Number, typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV void
- multiply_assign_scalar(Number &val, const OtherNumber &s)
+ multiply_assign_scalar(Number &val, const OtherNumber &s)
{
val *= s;
}
# ifdef __CUDA_ARCH__
template <typename Number, typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV void
- multiply_assign_scalar(std::complex<Number> &, const OtherNumber &)
+ multiply_assign_scalar(std::complex<Number> &, const OtherNumber &)
{
printf("This function is not implemented for std::complex<Number>!\n");
assert(false);
template <int rank_, int dim, typename Number>
template <typename ArrayLike, std::size_t... indices>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor<rank_, dim, Number>::Tensor(const ArrayLike &initializer,
+Tensor<rank_, dim, Number>::Tensor(const ArrayLike &initializer,
std::index_sequence<indices...>)
: values{Tensor<rank_ - 1, dim, Number>(initializer[indices])...}
{
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor<rank_, dim, Number>::Tensor()
+Tensor<rank_, dim, Number>::Tensor()
// We would like to use =default, but this causes compile errors with some
// MSVC versions and internal compiler errors with -O1 in gcc 5.4.
: values{}
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor<rank_, dim, Number>::Tensor(const array_type &initializer)
+Tensor<rank_, dim, Number>::Tensor(const array_type &initializer)
: Tensor(initializer, std::make_index_sequence<dim>{})
{}
template <int rank_, int dim, typename Number>
template <typename ElementType, typename MemorySpace>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor<rank_, dim, Number>::Tensor(
+Tensor<rank_, dim, Number>::Tensor(
const ArrayView<ElementType, MemorySpace> &initializer)
{
AssertDimension(initializer.size(), n_independent_components);
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor<rank_, dim, Number>::Tensor(
+Tensor<rank_, dim, Number>::Tensor(
const Tensor<rank_, dim, OtherNumber> &initializer)
: Tensor(initializer, std::make_index_sequence<dim>{})
{}
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_ALWAYS_INLINE Tensor<rank_, dim, Number>::
- operator Tensor<1, dim, Tensor<rank_ - 1, dim, OtherNumber>>() const
+operator Tensor<1, dim, Tensor<rank_ - 1, dim, OtherNumber>>() const
{
return Tensor<1, dim, Tensor<rank_ - 1, dim, Number>>(values);
}
template <int rank_, int dim, typename Number>
-constexpr inline DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- typename Tensor<rank_, dim, Number>::value_type &Tensor<rank_, dim, Number>::
- operator[](const unsigned int i)
+constexpr inline DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
+ typename Tensor<rank_, dim, Number>::value_type &
+ Tensor<rank_, dim, Number>::operator[](const unsigned int i)
{
return dealii::internal::TensorSubscriptor::subscript(
values, i, std::integral_constant<int, dim>());
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE
- DEAL_II_CUDA_HOST_DEV const typename Tensor<rank_, dim, Number>::value_type &
- Tensor<rank_, dim, Number>::operator[](const unsigned int i) const
+ DEAL_II_CUDA_HOST_DEV const typename Tensor<rank_, dim, Number>::value_type &
+ Tensor<rank_, dim, Number>::operator[](const unsigned int i) const
{
# ifndef DEAL_II_COMPILER_CUDA_AWARE
AssertIndexRange(i, dim);
template <int rank_, int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE const Number &
- Tensor<rank_, dim, Number>::
- operator[](const TableIndices<rank_> &indices) const
+Tensor<rank_, dim, Number>::operator[](const TableIndices<rank_> &indices) const
{
# ifndef DEAL_II_COMPILER_CUDA_AWARE
Assert(dim != 0,
template <int rank_, int dim, typename Number>
-constexpr inline DEAL_II_ALWAYS_INLINE Number &Tensor<rank_, dim, Number>::
- operator[](const TableIndices<rank_> &indices)
+constexpr inline DEAL_II_ALWAYS_INLINE Number &
+Tensor<rank_, dim, Number>::operator[](const TableIndices<rank_> &indices)
{
# ifndef DEAL_II_COMPILER_CUDA_AWARE
Assert(dim != 0,
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE Tensor<rank_, dim, Number> &
- Tensor<rank_, dim, Number>::
- operator=(Tensor<rank_, dim, Number> &&other) noexcept
+Tensor<rank_, dim, Number>::operator=(
+ Tensor<rank_, dim, Number> &&other) noexcept
{
for (unsigned int i = 0; i < dim; ++i)
values[i] = other.values[i];
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr inline bool
-Tensor<rank_, dim, Number>::
-operator==(const Tensor<rank_, dim, OtherNumber> &p) const
+Tensor<rank_, dim, Number>::operator==(
+ const Tensor<rank_, dim, OtherNumber> &p) const
{
for (unsigned int i = 0; i < dim; ++i)
if (values[i] != p.values[i])
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr bool
-Tensor<rank_, dim, Number>::
-operator!=(const Tensor<rank_, dim, OtherNumber> &p) const
+Tensor<rank_, dim, Number>::operator!=(
+ const Tensor<rank_, dim, OtherNumber> &p) const
{
return !((*this) == p);
}
template <typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
DEAL_II_CUDA_HOST_DEV Tensor<rank_, dim, Number> &
- Tensor<rank_, dim, Number>::
- operator+=(const Tensor<rank_, dim, OtherNumber> &p)
+ Tensor<rank_, dim, Number>::operator+=(
+ const Tensor<rank_, dim, OtherNumber> &p)
{
for (unsigned int i = 0; i < dim; ++i)
values[i] += p.values[i];
template <typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
DEAL_II_CUDA_HOST_DEV Tensor<rank_, dim, Number> &
- Tensor<rank_, dim, Number>::
- operator-=(const Tensor<rank_, dim, OtherNumber> &p)
+ Tensor<rank_, dim, Number>::operator-=(
+ const Tensor<rank_, dim, OtherNumber> &p)
{
for (unsigned int i = 0; i < dim; ++i)
values[i] -= p.values[i];
*/
template <int dim, typename Number, typename OtherNumber>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor<0, dim, typename ProductType<Number, OtherNumber>::type>
- operator+(const Tensor<0, dim, Number> & p,
+ Tensor<0, dim, typename ProductType<Number, OtherNumber>::type>
+ operator+(const Tensor<0, dim, Number> & p,
const Tensor<0, dim, OtherNumber> &q)
{
return static_cast<const Number &>(p) + static_cast<const OtherNumber &>(q);
*/
template <int dim, typename Number, typename OtherNumber>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
- Tensor<0, dim, typename ProductType<Number, OtherNumber>::type>
- operator-(const Tensor<0, dim, Number> & p,
+ Tensor<0, dim, typename ProductType<Number, OtherNumber>::type>
+ operator-(const Tensor<0, dim, Number> & p,
const Tensor<0, dim, OtherNumber> &q)
{
return static_cast<const Number &>(p) - static_cast<const OtherNumber &>(q);
* @relatesalso Tensor
*/
template <template <int, int, typename> class TensorT1,
- template <int, int, typename> class TensorT2,
- template <int, int, typename> class TensorT3,
+ template <int, int, typename>
+ class TensorT2,
+ template <int, int, typename>
+ class TensorT3,
int rank_1,
int rank_2,
int dim,
*/
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Tensor<1, dim, Number>
- cross_product_2d(const Tensor<1, dim, Number> &src)
+cross_product_2d(const Tensor<1, dim, Number> &src)
{
Assert(dim == 2, ExcInternalError());
*/
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Number
- determinant(const Tensor<2, dim, Number> &t)
+determinant(const Tensor<2, dim, Number> &t)
{
// Compute the determinant using the Laplace expansion of the
// determinant. We expand along the last row.
*/
template <typename Number>
constexpr DEAL_II_ALWAYS_INLINE Number
- determinant(const Tensor<2, 1, Number> &t)
+determinant(const Tensor<2, 1, Number> &t)
{
return t[0][0];
}
*/
template <typename Number>
constexpr DEAL_II_ALWAYS_INLINE Number
- determinant(const Tensor<2, 2, Number> &t)
+determinant(const Tensor<2, 2, Number> &t)
{
// hard-coded for efficiency reasons
return t[0][0] * t[1][1] - t[1][0] * t[0][1];
*/
template <typename Number>
constexpr DEAL_II_ALWAYS_INLINE Number
- determinant(const Tensor<2, 3, Number> &t)
+determinant(const Tensor<2, 3, Number> &t)
{
// hard-coded for efficiency reasons
const Number C0 = internal::NumberType<Number>::value(t[1][1] * t[2][2]) -
*/
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Number
- trace(const Tensor<2, dim, Number> &d)
+trace(const Tensor<2, dim, Number> &d)
{
Number t = d[0][0];
for (unsigned int i = 1; i < dim; ++i)
*/
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Tensor<2, dim, Number>
- transpose(const Tensor<2, dim, Number> &t)
+transpose(const Tensor<2, dim, Number> &t)
{
Tensor<2, dim, Number> tt;
for (unsigned int i = 0; i < dim; ++i)
// Recurse by applying index j directly:
constexpr DEAL_II_ALWAYS_INLINE value_type
- operator[](unsigned int j) const
+ operator[](unsigned int j) const
{
return value_type(t_[j]);
}
using value_type = StoreIndex<rank - 1, internal::Identity<T>>;
constexpr DEAL_II_ALWAYS_INLINE value_type
- operator[](unsigned int j) const
+ operator[](unsigned int j) const
{
return value_type(Identity<T>(t_), j);
}
typename ReferenceType<typename ValueType<T>::value_type>::type;
constexpr DEAL_II_ALWAYS_INLINE value_type
- operator[](unsigned int j) const
+ operator[](unsigned int j) const
{
return t_[j];
}
using value_type = StoreIndex<rank - 1, StoreIndex<rank, S>>;
constexpr DEAL_II_ALWAYS_INLINE value_type
- operator[](unsigned int j) const
+ operator[](unsigned int j) const
{
return value_type(*this, j);
}
* Dereferencing operator (const version): returns the value of the current
* lane.
*/
- const typename T::value_type &operator*() const
+ const typename T::value_type &
+ operator*() const
{
AssertIndexRange(lane, T::size());
return (*data)[lane];
* specialization).
*/
DEAL_II_ALWAYS_INLINE
- Number &operator[](const unsigned int comp)
+ Number &
+ operator[](const unsigned int comp)
{
(void)comp;
AssertIndexRange(comp, 1);
* without specialization).
*/
DEAL_II_ALWAYS_INLINE
- const Number &operator[](const unsigned int comp) const
+ const Number &
+ operator[](const unsigned int comp) const
{
(void)comp;
AssertIndexRange(comp, 1);
*/
template <typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
- make_vectorized_array(const typename VectorizedArrayType::value_type &u)
+make_vectorized_array(const typename VectorizedArrayType::value_type &u)
{
static_assert(
std::is_same<VectorizedArrayType,
* Access operator.
*/
DEAL_II_ALWAYS_INLINE
- double &operator[](const unsigned int comp)
+ double &
+ operator[](const unsigned int comp)
{
AssertIndexRange(comp, 8);
return *(reinterpret_cast<double *>(&data) + comp);
* Constant access operator.
*/
DEAL_II_ALWAYS_INLINE
- const double &operator[](const unsigned int comp) const
+ const double &
+ operator[](const unsigned int comp) const
{
AssertIndexRange(comp, 8);
return *(reinterpret_cast<const double *>(&data) + comp);
* Access operator.
*/
DEAL_II_ALWAYS_INLINE
- float &operator[](const unsigned int comp)
+ float &
+ operator[](const unsigned int comp)
{
AssertIndexRange(comp, 16);
return *(reinterpret_cast<float *>(&data) + comp);
* Constant access operator.
*/
DEAL_II_ALWAYS_INLINE
- const float &operator[](const unsigned int comp) const
+ const float &
+ operator[](const unsigned int comp) const
{
AssertIndexRange(comp, 16);
return *(reinterpret_cast<const float *>(&data) + comp);
* Access operator.
*/
DEAL_II_ALWAYS_INLINE
- double &operator[](const unsigned int comp)
+ double &
+ operator[](const unsigned int comp)
{
AssertIndexRange(comp, 4);
return *(reinterpret_cast<double *>(&data) + comp);
* Constant access operator.
*/
DEAL_II_ALWAYS_INLINE
- const double &operator[](const unsigned int comp) const
+ const double &
+ operator[](const unsigned int comp) const
{
AssertIndexRange(comp, 4);
return *(reinterpret_cast<const double *>(&data) + comp);
* Access operator.
*/
DEAL_II_ALWAYS_INLINE
- float &operator[](const unsigned int comp)
+ float &
+ operator[](const unsigned int comp)
{
AssertIndexRange(comp, 8);
return *(reinterpret_cast<float *>(&data) + comp);
* Constant access operator.
*/
DEAL_II_ALWAYS_INLINE
- const float &operator[](const unsigned int comp) const
+ const float &
+ operator[](const unsigned int comp) const
{
AssertIndexRange(comp, 8);
return *(reinterpret_cast<const float *>(&data) + comp);
* Access operator.
*/
DEAL_II_ALWAYS_INLINE
- double &operator[](const unsigned int comp)
+ double &
+ operator[](const unsigned int comp)
{
AssertIndexRange(comp, 2);
return *(reinterpret_cast<double *>(&data) + comp);
* Constant access operator.
*/
DEAL_II_ALWAYS_INLINE
- const double &operator[](const unsigned int comp) const
+ const double &
+ operator[](const unsigned int comp) const
{
AssertIndexRange(comp, 2);
return *(reinterpret_cast<const double *>(&data) + comp);
* Access operator.
*/
DEAL_II_ALWAYS_INLINE
- float &operator[](const unsigned int comp)
+ float &
+ operator[](const unsigned int comp)
{
AssertIndexRange(comp, 4);
return *(reinterpret_cast<float *>(&data) + comp);
* Constant access operator.
*/
DEAL_II_ALWAYS_INLINE
- const float &operator[](const unsigned int comp) const
+ const float &
+ operator[](const unsigned int comp) const
{
AssertIndexRange(comp, 4);
return *(reinterpret_cast<const float *>(&data) + comp);
* Access operator. The component must be either 0 or 1.
*/
DEAL_II_ALWAYS_INLINE
- double &operator[](const unsigned int comp)
+ double &
+ operator[](const unsigned int comp)
{
AssertIndexRange(comp, 2);
return *(reinterpret_cast<double *>(&data) + comp);
* Constant access operator.
*/
DEAL_II_ALWAYS_INLINE
- const double &operator[](const unsigned int comp) const
+ const double &
+ operator[](const unsigned int comp) const
{
AssertIndexRange(comp, 2);
return *(reinterpret_cast<const double *>(&data) + comp);
* Access operator. The component must be between 0 and 3.
*/
DEAL_II_ALWAYS_INLINE
- float &operator[](const unsigned int comp)
+ float &
+ operator[](const unsigned int comp)
{
AssertIndexRange(comp, 4);
return *(reinterpret_cast<float *>(&data) + comp);
* Constant access operator.
*/
DEAL_II_ALWAYS_INLINE
- const float &operator[](const unsigned int comp) const
+ const float &
+ operator[](const unsigned int comp) const
{
AssertIndexRange(comp, 4);
return *(reinterpret_cast<const float *>(&data) + comp);
*/
template <typename Number, std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
- operator+(const Number &u, const VectorizedArray<Number, width> &v)
+operator+(const Number &u, const VectorizedArray<Number, width> &v)
{
VectorizedArray<Number, width> tmp = u;
return tmp += v;
*/
template <std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
- operator+(const double u, const VectorizedArray<float, width> &v)
+operator+(const double u, const VectorizedArray<float, width> &v)
{
VectorizedArray<float, width> tmp = u;
return tmp += v;
*/
template <typename Number, std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
- operator+(const VectorizedArray<Number, width> &v, const Number &u)
+operator+(const VectorizedArray<Number, width> &v, const Number &u)
{
return u + v;
}
*/
template <std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
- operator+(const VectorizedArray<float, width> &v, const double u)
+operator+(const VectorizedArray<float, width> &v, const double u)
{
return u + v;
}
*/
template <typename Number, std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
- operator-(const Number &u, const VectorizedArray<Number, width> &v)
+operator-(const Number &u, const VectorizedArray<Number, width> &v)
{
VectorizedArray<Number, width> tmp = u;
return tmp -= v;
*/
template <std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
- operator-(const double u, const VectorizedArray<float, width> &v)
+operator-(const double u, const VectorizedArray<float, width> &v)
{
VectorizedArray<float, width> tmp = static_cast<float>(u);
return tmp -= v;
*/
template <typename Number, std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
- operator-(const VectorizedArray<Number, width> &v, const Number &u)
+operator-(const VectorizedArray<Number, width> &v, const Number &u)
{
VectorizedArray<Number, width> tmp = u;
return v - tmp;
*/
template <std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
- operator-(const VectorizedArray<float, width> &v, const double u)
+operator-(const VectorizedArray<float, width> &v, const double u)
{
VectorizedArray<float, width> tmp = static_cast<float>(u);
return v - tmp;
*/
template <typename Number, std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
- operator*(const Number &u, const VectorizedArray<Number, width> &v)
+operator*(const Number &u, const VectorizedArray<Number, width> &v)
{
VectorizedArray<Number, width> tmp = u;
return tmp *= v;
*/
template <std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
- operator*(const double u, const VectorizedArray<float, width> &v)
+operator*(const double u, const VectorizedArray<float, width> &v)
{
VectorizedArray<float, width> tmp = static_cast<float>(u);
return tmp *= v;
*/
template <typename Number, std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
- operator*(const VectorizedArray<Number, width> &v, const Number &u)
+operator*(const VectorizedArray<Number, width> &v, const Number &u)
{
return u * v;
}
*/
template <std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
- operator*(const VectorizedArray<float, width> &v, const double u)
+operator*(const VectorizedArray<float, width> &v, const double u)
{
return u * v;
}
*/
template <typename Number, std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
- operator/(const Number &u, const VectorizedArray<Number, width> &v)
+operator/(const Number &u, const VectorizedArray<Number, width> &v)
{
VectorizedArray<Number, width> tmp = u;
return tmp /= v;
*/
template <std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
- operator/(const double u, const VectorizedArray<float, width> &v)
+operator/(const double u, const VectorizedArray<float, width> &v)
{
VectorizedArray<float, width> tmp = static_cast<float>(u);
return tmp /= v;
*/
template <typename Number, std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
- operator/(const VectorizedArray<Number, width> &v, const Number &u)
+operator/(const VectorizedArray<Number, width> &v, const Number &u)
{
VectorizedArray<Number, width> tmp = u;
return v / tmp;
*/
template <std::size_t width>
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
- operator/(const VectorizedArray<float, width> &v, const double u)
+operator/(const VectorizedArray<float, width> &v, const double u)
{
VectorizedArray<float, width> tmp = static_cast<float>(u);
return v / tmp;
const unsigned int chunk_size = 8)
{
// forward to the other function
- run(begin,
- end,
- [&main_object, worker](const Iterator &iterator,
- ScratchData & scratch_data,
- CopyData & copy_data) {
- (main_object.*worker)(iterator, scratch_data, copy_data);
- },
- [&main_object, copier](const CopyData ©_data) {
- (main_object.*copier)(copy_data);
- },
- sample_scratch_data,
- sample_copy_data,
- queue_length,
- chunk_size);
+ run(
+ begin,
+ end,
+ [&main_object, worker](const Iterator &iterator,
+ ScratchData & scratch_data,
+ CopyData & copy_data) {
+ (main_object.*worker)(iterator, scratch_data, copy_data);
+ },
+ [&main_object, copier](const CopyData ©_data) {
+ (main_object.*copier)(copy_data);
+ },
+ sample_scratch_data,
+ sample_copy_data,
+ queue_length,
+ chunk_size);
}
const unsigned int chunk_size = 8)
{
// forward to the other function
- run(begin,
- end,
- [&main_object, worker](const Iterator &iterator,
- ScratchData & scratch_data,
- CopyData & copy_data) {
- (main_object.*worker)(iterator, scratch_data, copy_data);
- },
- [&main_object, copier](const CopyData ©_data) {
- (main_object.*copier)(copy_data);
- },
- sample_scratch_data,
- sample_copy_data,
- queue_length,
- chunk_size);
+ run(
+ begin,
+ end,
+ [&main_object, worker](const Iterator &iterator,
+ ScratchData & scratch_data,
+ CopyData & copy_data) {
+ (main_object.*worker)(iterator, scratch_data, copy_data);
+ },
+ [&main_object, copier](const CopyData ©_data) {
+ (main_object.*copier)(copy_data);
+ },
+ sample_scratch_data,
+ sample_copy_data,
+ queue_length,
+ chunk_size);
}
* @p t to the given @p value.
*/
template <int dim, typename NumberType>
- inline void set_tensor_entry(Tensor<0, dim, NumberType> &t,
- const unsigned int unrolled_index,
- const NumberType & value)
+ inline void
+ set_tensor_entry(Tensor<0, dim, NumberType> &t,
+ const unsigned int unrolled_index,
+ const NumberType & value)
{
AssertIndexRange(unrolled_index, 1);
(void)unrolled_index;
* @p t to the given @p value.
*/
template <int dim, typename NumberType>
- inline void set_tensor_entry(SymmetricTensor<4, dim, NumberType> &t,
- const unsigned int unrolled_index_row,
- const unsigned int unrolled_index_col,
- const NumberType & value)
+ inline void
+ set_tensor_entry(SymmetricTensor<4, dim, NumberType> &t,
+ const unsigned int unrolled_index_row,
+ const unsigned int unrolled_index_col,
+ const NumberType & value)
{
// Fourth order symmetric tensors require a specialized interface
// to extract values.
template <int rank,
int dim,
typename NumberType,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
inline NumberType
get_tensor_entry(const TensorType<rank, dim, NumberType> &t,
const unsigned int unrolled_index)
*/
template <int dim,
typename NumberType,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
inline NumberType
get_tensor_entry(const TensorType<0, dim, NumberType> &t,
const unsigned int unrolled_index)
template <int rank,
int dim,
typename NumberType,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
inline NumberType &
get_tensor_entry(TensorType<rank, dim, NumberType> &t,
const unsigned int unrolled_index)
*/
template <int dim,
typename NumberType,
- template <int, int, typename> class TensorType>
- NumberType &get_tensor_entry(TensorType<0, dim, NumberType> &t,
- const unsigned int index)
+ template <int, int, typename>
+ class TensorType>
+ NumberType &
+ get_tensor_entry(TensorType<0, dim, NumberType> &t,
+ const unsigned int index)
{
AssertIndexRange(index, 1);
(void)index;
* @note This operator can only be applied on boolean and conditional
* expressions.
*/
- Expression operator!(const Expression &expression);
+ Expression
+ operator!(const Expression &expression);
/**
* Logical and operator.
* @note This operator can only be applied on boolean and conditional
* expressions.
*/
- Expression operator&(const Expression &lhs, const Expression &rhs);
+ Expression
+ operator&(const Expression &lhs, const Expression &rhs);
/**
* Logical inclusive or operator.
*
* Return the result of multiplying the @p lhs by the @p rhs.
*/
- Expression operator*(Expression lhs, const Expression &rhs);
+ Expression
+ operator*(Expression lhs, const Expression &rhs);
/**
* Division operator.
template <typename NumberType,
typename = typename std::enable_if<
std::is_constructible<Expression, NumberType>::value>::type>
- inline Expression operator*(const NumberType &lhs, const Expression &rhs)
+ inline Expression
+ operator*(const NumberType &lhs, const Expression &rhs)
{
return Expression(lhs) * rhs;
}
template <typename NumberType,
typename = typename std::enable_if<
std::is_constructible<Expression, NumberType>::value>::type>
- inline Expression operator*(const Expression &lhs, const NumberType &rhs)
+ inline Expression
+ operator*(const Expression &lhs, const NumberType &rhs)
{
return lhs * Expression(rhs);
}
// <tt>operator |</tt> would be an integer which would in turn trigger a
// compiler warning when we tried to assign it to an object of type
// OptimizationFlags.
- inline OptimizationFlags operator&(const OptimizationFlags f1,
- const OptimizationFlags f2)
+ inline OptimizationFlags
+ operator&(const OptimizationFlags f1, const OptimizationFlags f2)
{
return static_cast<OptimizationFlags>(static_cast<unsigned int>(f1) &
static_cast<unsigned int>(f2));
template <typename NumberType,
int rank,
int dim,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
TensorType<rank, dim, NumberType>
tensor_evaluate_optimized(
const TensorType<rank, dim, Expression> &symbol_tensor,
void
register_functions(BatchOptimizer<NumberType> &optimizer,
const T & function,
- const Args &... other_functions)
+ const Args &...other_functions)
{
register_functions(optimizer, function);
register_functions(optimizer, other_functions...);
*/
template <int rank,
int dim,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
types::symbol_vector
unroll_to_expression_vector(
const TensorType<rank, dim, Expression> &symbol_tensor)
*/
template <typename T, typename... Args>
void
- register_functions(const T &functions, const Args &... other_functions);
+ register_functions(const T &functions, const Args &...other_functions);
/**
* Return a vector of expressions that have been registered as dependent
void
BatchOptimizer<ReturnType>::register_functions(
const T &functions,
- const Args &... other_functions)
+ const Args &...other_functions)
{
internal::register_functions(*this, functions);
internal::register_functions(*this, other_functions...);
typename SymbolicType,
typename... Args>
types::substitution_map
- make_symbol_map(const SymbolicType &symbol, const Args &... other_symbols);
+ make_symbol_map(const SymbolicType &symbol, const Args &...other_symbols);
/**
* A convenience function for adding an empty entry, with the key value
void
add_to_symbol_map(types::substitution_map &symbol_map,
const SymbolicType & symbol,
- const Args &... other_symbols);
+ const Args &...other_symbols);
/**
* Find the entry for @p symbol in the @p substitution_map and set its
set_value_in_symbol_map(
types::substitution_map & substitution_map,
const std::pair<SymbolicType, ValueType> &symbol_value,
- const Args &... other_symbol_values);
+ const Args &...other_symbol_values);
/**
* Find the entries for @p symbols in the @p substitution_map and set their
types::substitution_map
make_substitution_map(
const std::pair<ExpressionType, ValueType> &symbol_value,
- const Args &... other_symbol_values);
+ const Args &...other_symbol_values);
//@}
add_to_substitution_map(
types::substitution_map & substitution_map,
const std::pair<ExpressionType, ValueType> &symbol_value,
- const Args &... other_symbol_values);
+ const Args &...other_symbol_values);
/**
* Concatenate two symbolic maps, merging a second map @p substitution_map_in
void
merge_substitution_maps(types::substitution_map & substitution_map_out,
const types::substitution_map &substitution_map_in,
- const Args &... other_substitution_maps_in);
+ const Args &...other_substitution_maps_in);
/**
* Concatenate multiple symbolic maps, merging the maps @p substitution_map_in
template <typename... Args>
types::substitution_map
merge_substitution_maps(const types::substitution_map &substitution_map_in,
- const Args &... other_substitution_maps_in);
+ const Args &...other_substitution_maps_in);
//@}
*/
template <typename ExpressionType, typename... Args>
ExpressionType
- substitute(const ExpressionType &expression, const Args &... symbol_values);
+ substitute(const ExpressionType &expression, const Args &...symbol_values);
/**
* Perform a single substitution sweep of a set of symbols into the given
template <typename ValueType, typename... Args>
ValueType
substitute_and_evaluate(const Expression &expression,
- const Args &... symbol_values);
+ const Args &...symbol_values);
//@}
typename SymbolicType,
typename... Args>
types::substitution_map
- make_symbol_map(const SymbolicType &symbol, const Args &... other_symbols)
+ make_symbol_map(const SymbolicType &symbol, const Args &...other_symbols)
{
types::substitution_map symbol_map;
add_to_symbol_map<ignore_invalid_symbols, ValueType>(symbol_map,
void
add_to_symbol_map(types::substitution_map &symbol_map,
const SymbolicType & symbol,
- const Args &... other_symbols)
+ const Args &...other_symbols)
{
add_to_symbol_map<ignore_invalid_symbols, ValueType>(symbol_map, symbol);
add_to_symbol_map<ignore_invalid_symbols, ValueType>(symbol_map,
set_value_in_symbol_map(
types::substitution_map & substitution_map,
const std::pair<SymbolicType, ValueType> &symbol_value,
- const Args &... other_symbol_values)
+ const Args &...other_symbol_values)
{
set_value_in_symbol_map(substitution_map, symbol_value);
set_value_in_symbol_map(substitution_map, other_symbol_values...);
types::substitution_map
make_substitution_map(
const std::pair<ExpressionType, ValueType> &symbol_value,
- const Args &... other_symbol_values)
+ const Args &...other_symbol_values)
{
types::substitution_map substitution_map;
add_to_substitution_map(substitution_map,
add_to_substitution_map(
types::substitution_map & substitution_map,
const std::pair<ExpressionType, ValueType> &symbol_value,
- const Args &... other_symbol_values)
+ const Args &...other_symbol_values)
{
add_to_substitution_map<ignore_invalid_symbols>(substitution_map,
symbol_value);
types::substitution_map
merge_substitution_maps(
const types::substitution_map &substitution_map_in_1,
- const Args &... other_substitution_maps_in)
+ const Args &...other_substitution_maps_in)
{
types::substitution_map substitution_map_out = substitution_map_in_1;
merge_substitution_maps(substitution_map_out,
merge_substitution_maps(
types::substitution_map & substitution_map_out,
const types::substitution_map &substitution_map_in_1,
- const Args &... other_substitution_maps_in)
+ const Args &...other_substitution_maps_in)
{
merge_substitution_maps(substitution_map_out, substitution_map_in_1);
merge_substitution_maps(substitution_map_out,
template <typename ExpressionType, typename... Args>
ExpressionType
- substitute(const ExpressionType &expression, const Args &... symbol_values)
+ substitute(const ExpressionType &expression, const Args &...symbol_values)
{
// Call other function
return substitute(expression, make_substitution_map(symbol_values...));
template <typename ValueType, typename... Args>
ValueType
substitute_and_evaluate(const Expression &expression,
- const Args &... symbol_values)
+ const Args &...symbol_values)
{
// Call other function
return substitute_and_evaluate<ValueType>(
template <int dim,
typename ValueType = Expression,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
TensorType<0, dim, ValueType>
scalar_diff_tensor(const ValueType & func,
const TensorType<0, dim, ValueType> &op)
template <int rank,
int dim,
typename ValueType = Expression,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
TensorType<rank, dim, ValueType>
scalar_diff_tensor(const ValueType & func,
const TensorType<rank, dim, ValueType> &op)
template <int rank,
int dim,
typename ValueType = Expression,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
TensorType<rank, dim, ValueType>
tensor_diff_tensor(const TensorType<0, dim, ValueType> & func,
const TensorType<rank, dim, ValueType> &op)
template <int rank,
int dim,
typename ValueType = Expression,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
TensorType<rank, dim, ValueType>
tensor_diff_scalar(const TensorType<rank, dim, ValueType> &funcs,
const ValueType & op)
template <int rank,
int dim,
typename ValueType = Expression,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
TensorType<rank, dim, ValueType>
tensor_diff_tensor(const TensorType<rank, dim, ValueType> &funcs,
const TensorType<0, dim, ValueType> & op)
int rank_2,
int dim,
typename ValueType = Expression,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
TensorType<rank_1 + rank_2, dim, ValueType>
tensor_diff_tensor(const TensorType<rank_1, dim, ValueType> &funcs,
const TensorType<rank_2, dim, ValueType> &op)
int rank_2,
int dim,
typename ValueType = Expression,
- template <int, int, typename> class TensorType_1,
- template <int, int, typename> class TensorType_2>
+ template <int, int, typename>
+ class TensorType_1,
+ template <int, int, typename>
+ class TensorType_2>
Tensor<rank_1 + rank_2, dim, ValueType>
tensor_diff_tensor(const TensorType_1<rank_1, dim, ValueType> &funcs,
const TensorType_2<rank_2, dim, ValueType> &op)
typename ValueType,
int rank,
int dim,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
void
set_tensor_value_in_symbol_map(
types::substitution_map & substitution_map,
int dim,
typename ExpressionType,
typename ValueType,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
std::vector<std::pair<ExpressionType, ValueType>>
make_tensor_entries_for_substitution_map(
const TensorType<rank, dim, ExpressionType> &symbol_tensor,
{
template <int rank,
int dim,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
TensorType<rank, dim, Expression>
substitute_tensor(
const TensorType<rank, dim, Expression> &expression_tensor,
template <typename ValueType,
int rank,
int dim,
- template <int, int, typename> class TensorType>
+ template <int, int, typename>
+ class TensorType>
TensorType<rank, dim, ValueType>
substitute_and_evaluate_tensor(
const TensorType<rank, dim, Expression> &expression_tensor,
template <int spacedim>
static void
- iterate(dealii::internal::p4est::types<2>::forest *parallel_forest,
- dealii::internal::p4est::types<2>::ghost * parallel_ghost,
- void * user_data);
+ iterate(dealii::internal::p4est::types<2>::forest *parallel_forest,
+ dealii::internal::p4est::types<2>::ghost * parallel_ghost,
+ void * user_data);
static constexpr unsigned int max_level = P4EST_MAXLEVEL;
explicit Triangulation(
const MPI_Comm &mpi_communicator,
const typename dealii::Triangulation<dim, spacedim>::MeshSmoothing
- smooth_grid = (dealii::Triangulation<dim, spacedim>::none),
- const Settings settings = default_setting);
+ smooth_grid = (dealii::Triangulation<dim, spacedim>::none),
+ const Settings settings = default_setting);
/**
* Destructor.
*
* This function exists in 2d and 3d variants.
*/
- void
- copy_new_triangulation_to_p4est(std::integral_constant<int, 2>);
- void
- copy_new_triangulation_to_p4est(std::integral_constant<int, 3>);
+ void copy_new_triangulation_to_p4est(std::integral_constant<int, 2>);
+ void copy_new_triangulation_to_p4est(std::integral_constant<int, 3>);
/**
* Copy the local part of the refined forest from p4est into the
/**
* Move assignment operator.
*/
- DoFAccessor<0, 1, spacedim, level_dof_access> &operator =(
- DoFAccessor<0, 1, spacedim, level_dof_access> &&) noexcept = default;
+ DoFAccessor<0, 1, spacedim, level_dof_access> &
+ operator=(DoFAccessor<0, 1, spacedim, level_dof_access> &&) noexcept =
+ default;
/**
* @}
/**
* Reset the DoF handler pointer.
*/
- void set_dof_handler(DoFHandler<1, spacedim> *dh);
+ void
+ set_dof_handler(DoFHandler<1, spacedim> *dh);
/**
* Set the index of the <i>i</i>th degree of freedom of this object to @p
dof_processor);
// 4) INNER dofs
- dof_operation.process_dofs(accessor,
- [&](const auto d) { return d; },
- index,
- dof_indices,
- fe_index,
- dof_processor);
+ dof_operation.process_dofs(
+ accessor,
+ [&](const auto d) { return d; },
+ index,
+ dof_indices,
+ fe_index,
+ dof_processor);
AssertDimension(n_dof_indices(accessor, fe_index, count_level_dofs),
index);
DoFHandler<dim, spacedim>::default_fe_index :
fe_index_;
- process_object(accessor.get_dof_handler(),
- 0,
- accessor.vertex_index(vertex),
- fe_index,
- [](const auto d) {
- Assert(false, ExcInternalError());
- return d;
- },
- std::integral_constant<int, 0>(),
- index_value,
- index,
- dof_processor);
+ process_object(
+ accessor.get_dof_handler(),
+ 0,
+ accessor.vertex_index(vertex),
+ fe_index,
+ [](const auto d) {
+ Assert(false, ExcInternalError());
+ return d;
+ },
+ std::integral_constant<int, 0>(),
+ index_value,
+ index,
+ dof_processor);
}
/**
template <int spacedim, bool level_dof_access>
-inline void DoFAccessor<0, 1, spacedim, level_dof_access>::set_dof_handler(
+inline void
+DoFAccessor<0, 1, spacedim, level_dof_access>::set_dof_handler(
DoFHandler<1, spacedim> *dh)
{
Assert(dh != nullptr, ExcInvalidObject());
{
if (this->hp_capability_enabled)
{
- ar & this->object_dof_indices;
- ar & this->object_dof_ptr;
+ ar &this->object_dof_indices;
+ ar &this->object_dof_ptr;
- ar & this->cell_dof_cache_indices;
- ar & this->cell_dof_cache_ptr;
+ ar &this->cell_dof_cache_indices;
+ ar &this->cell_dof_cache_ptr;
- ar & this->hp_cell_active_fe_indices;
- ar & this->hp_cell_future_fe_indices;
+ ar &this->hp_cell_active_fe_indices;
+ ar &this->hp_cell_future_fe_indices;
ar &hp_object_fe_ptr;
ar &hp_object_fe_indices;
}
else
{
- ar & this->block_info_object;
+ ar &this->block_info_object;
ar &number_cache;
- ar & this->object_dof_indices;
- ar & this->object_dof_ptr;
+ ar &this->object_dof_indices;
+ ar &this->object_dof_ptr;
- ar & this->cell_dof_cache_indices;
- ar & this->cell_dof_cache_ptr;
+ ar &this->cell_dof_cache_indices;
+ ar &this->cell_dof_cache_ptr;
// write out the number of triangulation cells and later check during
// loading that this number is indeed correct; same with something that
{
if (this->hp_capability_enabled)
{
- ar & this->object_dof_indices;
- ar & this->object_dof_ptr;
+ ar &this->object_dof_indices;
+ ar &this->object_dof_ptr;
- ar & this->cell_dof_cache_indices;
- ar & this->cell_dof_cache_ptr;
+ ar &this->cell_dof_cache_indices;
+ ar &this->cell_dof_cache_ptr;
- ar & this->hp_cell_active_fe_indices;
- ar & this->hp_cell_future_fe_indices;
+ ar &this->hp_cell_active_fe_indices;
+ ar &this->hp_cell_future_fe_indices;
ar &hp_object_fe_ptr;
ar &hp_object_fe_indices;
}
else
{
- ar & this->block_info_object;
+ ar &this->block_info_object;
ar &number_cache;
object_dof_indices.clear();
object_dof_ptr.clear();
- ar & this->object_dof_indices;
- ar & this->object_dof_ptr;
+ ar &this->object_dof_indices;
+ ar &this->object_dof_ptr;
- ar & this->cell_dof_cache_indices;
- ar & this->cell_dof_cache_ptr;
+ ar &this->cell_dof_cache_indices;
+ ar &this->cell_dof_cache_ptr;
// these are the checks that correspond to the last block in the save()
// function
* given index needs to be between zero and the number of blocks that this
* mask represents.
*/
- bool operator[](const unsigned int block_index) const;
+ bool
+ operator[](const unsigned int block_index) const;
/**
* Return whether this block mask represents a mask with exactly
* Return a block mask that has only those elements set that are set both in
* the current object as well as the one passed as an argument.
*/
- BlockMask operator&(const BlockMask &mask) const;
+ BlockMask
+ operator&(const BlockMask &mask) const;
/**
* Return whether this object and the argument are identical.
}
-inline bool BlockMask::operator[](const unsigned int block_index) const
+inline bool
+BlockMask::operator[](const unsigned int block_index) const
{
// if the mask represents the all-block mask
// then always return true
}
-inline BlockMask BlockMask::operator&(const BlockMask &mask) const
+inline BlockMask
+BlockMask::operator&(const BlockMask &mask) const
{
// if one of the two masks denotes the all-block mask,
// then return the other one
* Otherwise, the given index needs to be between zero and the number of
* components that this mask represents.
*/
- bool operator[](const unsigned int component_index) const;
+ bool
+ operator[](const unsigned int component_index) const;
/**
* Return whether this component mask represents a mask with exactly
* Return a component mask that has only those elements set that are set
* both in the current object as well as the one passed as an argument.
*/
- ComponentMask operator&(const ComponentMask &mask) const;
+ ComponentMask
+ operator&(const ComponentMask &mask) const;
/**
* Return whether this object and the argument are identical.
}
-inline bool ComponentMask::operator[](const unsigned int component_index) const
+inline bool
+ComponentMask::operator[](const unsigned int component_index) const
{
// if the mask represents the all-component mask
// then always return true
}
-inline ComponentMask ComponentMask::operator&(const ComponentMask &mask) const
+inline ComponentMask
+ComponentMask::operator&(const ComponentMask &mask) const
{
// if one of the two masks denotes the all-component mask,
// then return the other one
template <int dim, int spacedim>
-inline const FiniteElement<dim, spacedim> &FiniteElement<dim, spacedim>::
- operator[](const unsigned int fe_index) const
+inline const FiniteElement<dim, spacedim> &
+FiniteElement<dim, spacedim>::operator[](const unsigned int fe_index) const
{
(void)fe_index;
Assert(fe_index == 0,
* <code>other_element_dominates</code>, then the returned value is
* <code>neither_element_dominates</code>.
*/
- inline Domination operator&(const Domination d1, const Domination d2);
+ inline Domination
+ operator&(const Domination d1, const Domination d2);
} // namespace FiniteElementDomination
namespace internal
namespace FiniteElementDomination
{
- inline Domination operator&(const Domination d1, const Domination d2)
+ inline Domination
+ operator&(const Domination d1, const Domination d2)
{
// go through the entire list of possibilities. note that if we were into
// speed, obfuscation and cared enough, we could implement this operator
/*------------ Inline functions: FEInterfaceValues------------*/
template <int dim, int spacedim>
inline const FEInterfaceViews::Scalar<dim, spacedim>
- FEInterfaceValues<dim, spacedim>::
- operator[](const FEValuesExtractors::Scalar &scalar) const
+FEInterfaceValues<dim, spacedim>::operator[](
+ const FEValuesExtractors::Scalar &scalar) const
{
AssertIndexRange(scalar.component, this->get_fe().n_components());
return FEInterfaceViews::Scalar<dim, spacedim>(*this, scalar.component);
template <int dim, int spacedim>
inline const FEInterfaceViews::Vector<dim, spacedim>
- FEInterfaceValues<dim, spacedim>::
- operator[](const FEValuesExtractors::Vector &vector) const
+FEInterfaceValues<dim, spacedim>::operator[](
+ const FEValuesExtractors::Vector &vector) const
{
const FiniteElement<dim, spacedim> &fe = this->get_fe();
const unsigned int n_vectors =
unsigned int>>::value ||
std::is_base_of<FiniteElement<dim, spacedim>,
typename std::decay<FEPairs>::type>::value)...>::type>
- FESystem(FEPairs &&... fe_pairs);
+ FESystem(FEPairs &&...fe_pairs);
/**
* Same as above allowing the following syntax:
// of the std::enable_if.
template <int dim, int spacedim>
template <class... FEPairs, typename>
-FESystem<dim, spacedim>::FESystem(FEPairs &&... fe_pairs)
+FESystem<dim, spacedim>::FESystem(FEPairs &&...fe_pairs)
: FESystem<dim, spacedim>(
{internal::FESystemImplementation::promote_to_fe_pair<dim, spacedim>(
std::forward<FEPairs>(fe_pairs))...})
// finally loop over all possible refinement cases
Threads::TaskGroup<> tasks;
unsigned int ref_case = (isotropic_only) ?
- RefinementCase<dim>::isotropic_refinement :
- RefinementCase<dim>::cut_x;
+ RefinementCase<dim>::isotropic_refinement :
+ RefinementCase<dim>::cut_x;
for (; ref_case <= RefinementCase<dim>::isotropic_refinement; ++ref_case)
tasks += Threads::new_task([&, ref_case]() {
compute_one_case(ref_case, mass, matrices[ref_case - 1]);
*
* @ref UpdateFlags
*/
-inline UpdateFlags operator&(const UpdateFlags f1, const UpdateFlags f2)
+inline UpdateFlags
+operator&(const UpdateFlags f1, const UpdateFlags f2)
{
return static_cast<UpdateFlags>(static_cast<unsigned int>(f1) &
static_cast<unsigned int>(f2));
template <int dim, int spacedim>
-inline const FEValuesViews::Scalar<dim, spacedim> &FEValuesBase<dim, spacedim>::
- operator[](const FEValuesExtractors::Scalar &scalar) const
+inline const FEValuesViews::Scalar<dim, spacedim> &
+FEValuesBase<dim, spacedim>::operator[](
+ const FEValuesExtractors::Scalar &scalar) const
{
AssertIndexRange(scalar.component, fe_values_views_cache.scalars.size());
template <int dim, int spacedim>
-inline const FEValuesViews::Vector<dim, spacedim> &FEValuesBase<dim, spacedim>::
- operator[](const FEValuesExtractors::Vector &vector) const
+inline const FEValuesViews::Vector<dim, spacedim> &
+FEValuesBase<dim, spacedim>::operator[](
+ const FEValuesExtractors::Vector &vector) const
{
AssertIndexRange(vector.first_vector_component,
fe_values_views_cache.vectors.size());
template <int dim, int spacedim>
inline const FEValuesViews::SymmetricTensor<2, dim, spacedim> &
- FEValuesBase<dim, spacedim>::
- operator[](const FEValuesExtractors::SymmetricTensor<2> &tensor) const
+FEValuesBase<dim, spacedim>::operator[](
+ const FEValuesExtractors::SymmetricTensor<2> &tensor) const
{
Assert(
tensor.first_tensor_component <
template <int dim, int spacedim>
inline const FEValuesViews::Tensor<2, dim, spacedim> &
- FEValuesBase<dim, spacedim>::
- operator[](const FEValuesExtractors::Tensor<2> &tensor) const
+FEValuesBase<dim, spacedim>::operator[](
+ const FEValuesExtractors::Tensor<2> &tensor) const
{
AssertIndexRange(tensor.first_tensor_component,
fe_values_views_cache.second_order_tensors.size());
template <typename BaseIterator>
template <typename Predicate>
bool
-FilteredIterator<BaseIterator>::PredicateTemplate<Predicate>::
-operator()(const BaseIterator &bi) const
+FilteredIterator<BaseIterator>::PredicateTemplate<Predicate>::operator()(
+ const BaseIterator &bi) const
{
return predicate(bi);
}
* @param[in] rotate_right_square <code>true</code> if the right square is
* rotated by $\pi/2$.
*/
- void non_standard_orientation_mesh(Triangulation<2> &tria,
- const bool rotate_left_square,
- const bool rotate_right_square);
+ void
+ non_standard_orientation_mesh(Triangulation<2> &tria,
+ const bool rotate_left_square,
+ const bool rotate_right_square);
/**
* Generate a 3D mesh consisting of the unit cube joined with a copy shifted
* @param[in] manipulate_left_cube <code>true</code> if the left cube is
* to be re-ordered. If `false`, it is the right cube.
*/
- void non_standard_orientation_mesh(Triangulation<3> &tria,
- const bool face_orientation,
- const bool face_flip,
- const bool face_rotation,
- const bool manipulate_left_cube);
+ void
+ non_standard_orientation_mesh(Triangulation<3> &tria,
+ const bool face_orientation,
+ const bool face_flip,
+ const bool face_rotation,
+ const bool manipulate_left_cube);
/**
* this function.
*/
template <int spacedim>
- void hyper_sphere(Triangulation<spacedim - 1, spacedim> &tria,
- const Point<spacedim> ¢er = Point<spacedim>(),
- const double radius = 1.);
+ void
+ hyper_sphere(Triangulation<spacedim - 1, spacedim> &tria,
+ const Point<spacedim> ¢er = Point<spacedim>(),
+ const double radius = 1.);
/**
* This function produces a hyper-ball intersected with the positive orthant
* of the torus containing the loop of cells. Must be greater than @p r.
* @param r The radius of the cylinder bent together as a loop.
*/
- void moebius(Triangulation<3, 3> &tria,
- const unsigned int n_cells,
- const unsigned int n_rotations,
- const double R,
- const double r);
+ void
+ moebius(Triangulation<3, 3> &tria,
+ const unsigned int n_cells,
+ const unsigned int n_rotations,
+ const double R,
+ const double r);
/**
* Call one of the other GridGenerator functions, parsing the name of the
// These functions are only implemented with specializations; declare them
// here
template <>
- void hyper_cube_with_cylindrical_hole(Triangulation<1> &,
- const double,
- const double,
- const double,
- const unsigned int,
- const bool);
+ void
+ hyper_cube_with_cylindrical_hole(Triangulation<1> &,
+ const double,
+ const double,
+ const double,
+ const unsigned int,
+ const bool);
template <>
- void hyper_cube_with_cylindrical_hole(Triangulation<2> &,
- const double,
- const double,
- const double,
- const unsigned int,
- const bool);
+ void
+ hyper_cube_with_cylindrical_hole(Triangulation<2> &,
+ const double,
+ const double,
+ const double,
+ const unsigned int,
+ const bool);
template <>
- void hyper_cube_with_cylindrical_hole(Triangulation<3> &,
- const double,
- const double,
- const double,
- const unsigned int,
- const bool);
+ void
+ hyper_cube_with_cylindrical_hole(Triangulation<3> &,
+ const double,
+ const double,
+ const double,
+ const unsigned int,
+ const bool);
template <>
- void channel_with_cylinder(Triangulation<1> &,
- const double,
- const unsigned int,
- const double,
- const bool);
+ void
+ channel_with_cylinder(Triangulation<1> &,
+ const double,
+ const unsigned int,
+ const double,
+ const bool);
template <>
- void channel_with_cylinder(Triangulation<2> &,
- const double,
- const unsigned int,
- const double,
- const bool);
+ void
+ channel_with_cylinder(Triangulation<2> &,
+ const double,
+ const unsigned int,
+ const double,
+ const bool);
template <>
- void channel_with_cylinder(Triangulation<3> &,
- const double,
- const unsigned int,
- const double,
- const bool);
+ void
+ channel_with_cylinder(Triangulation<3> &,
+ const double,
+ const unsigned int,
+ const double,
+ const bool);
#endif
} // namespace GridGenerator
const Cache<dim, spacedim> &cache,
const Point<spacedim> & p,
const typename Triangulation<dim, spacedim>::active_cell_iterator &
- cell_hint = typename Triangulation<dim, spacedim>::active_cell_iterator(),
+ cell_hint = typename Triangulation<dim, spacedim>::active_cell_iterator(),
const std::vector<bool> &marked_vertices = {},
const double tolerance = 1.e-10);
* article.
*/
template <typename FaceIterator>
- bool orthogonal_equality(
+ bool
+ orthogonal_equality(
std::bitset<3> & orientation,
const FaceIterator & face1,
const FaceIterator & face2,
std::vector<std::vector<typename CellId::binary_type>> cell_data_to_send(
ghost_owners.size());
std::vector<std::vector<types::global_dof_index>>
- send_dof_numbers_and_indices(ghost_owners.size());
+ send_dof_numbers_and_indices(ghost_owners.size());
std::vector<MPI_Request> reply_requests(ghost_owners.size());
std::vector<std::vector<char>> sendbuffers(ghost_owners.size());
*
* @ref CacheUpdateFlags
*/
- inline CacheUpdateFlags operator&(const CacheUpdateFlags f1,
- const CacheUpdateFlags f2)
+ inline CacheUpdateFlags
+ operator&(const CacheUpdateFlags f1, const CacheUpdateFlags f2)
{
return static_cast<CacheUpdateFlags>(static_cast<unsigned int>(f1) &
static_cast<unsigned int>(f2));
* refined cell of which the source cell would be created if it were further
* refined.
*/
- cell_iterator operator[](const cell_iterator &source_cell) const;
+ cell_iterator
+ operator[](const cell_iterator &source_cell) const;
/**
* Delete all data of this class.
* called by anyone, but at least hidden in an internal namespace.
*/
friend DEAL_II_CONSTEXPR ReferenceCell
- internal::ReferenceCell::make_reference_cell_from_int(const std::uint8_t);
+ internal::ReferenceCell::make_reference_cell_from_int(const std::uint8_t);
};
namespace ReferenceCell
{
inline DEAL_II_CONSTEXPR dealii::ReferenceCell
- make_reference_cell_from_int(const std::uint8_t kind)
+ make_reference_cell_from_int(const std::uint8_t kind)
{
// Make sure these are the only indices from which objects can be
// created.
template <int structdim, int dim, int spacedim>
inline TriaAccessorBase<structdim, dim, spacedim> &
-TriaAccessorBase<structdim, dim, spacedim>::
-operator=(const TriaAccessorBase<structdim, dim, spacedim> &a)
+TriaAccessorBase<structdim, dim, spacedim>::operator=(
+ const TriaAccessorBase<structdim, dim, spacedim> &a)
{
present_level = a.present_level;
present_index = a.present_index;
template <int structdim, int dim, int spacedim>
inline bool
-TriaAccessorBase<structdim, dim, spacedim>::
-operator==(const TriaAccessorBase<structdim, dim, spacedim> &a) const
+TriaAccessorBase<structdim, dim, spacedim>::operator==(
+ const TriaAccessorBase<structdim, dim, spacedim> &a) const
{
Assert(tria == a.tria || tria == nullptr || a.tria == nullptr,
TriaAccessorExceptions::ExcCantCompareIterators());
template <int structdim, int dim, int spacedim>
inline bool
-TriaAccessorBase<structdim, dim, spacedim>::
-operator!=(const TriaAccessorBase<structdim, dim, spacedim> &a) const
+TriaAccessorBase<structdim, dim, spacedim>::operator!=(
+ const TriaAccessorBase<structdim, dim, spacedim> &a) const
{
Assert(tria == a.tria || tria == nullptr || a.tria == nullptr,
TriaAccessorExceptions::ExcCantCompareIterators());
template <int structdim, int dim, int spacedim>
inline bool
-TriaAccessorBase<structdim, dim, spacedim>::
-operator<(const TriaAccessorBase<structdim, dim, spacedim> &other) const
+TriaAccessorBase<structdim, dim, spacedim>::operator<(
+ const TriaAccessorBase<structdim, dim, spacedim> &other) const
{
Assert(tria == other.tria, TriaAccessorExceptions::ExcCantCompareIterators());
template <int structdim, int dim, int spacedim>
bool
-InvalidAccessor<structdim, dim, spacedim>::
-operator==(const InvalidAccessor &) const
+InvalidAccessor<structdim, dim, spacedim>::operator==(
+ const InvalidAccessor &) const
{
// nothing to do here. we could
// throw an exception but we can't
template <int structdim, int dim, int spacedim>
bool
-InvalidAccessor<structdim, dim, spacedim>::
-operator!=(const InvalidAccessor &) const
+InvalidAccessor<structdim, dim, spacedim>::operator!=(
+ const InvalidAccessor &) const
{
// nothing to do here. we could
// throw an exception but we can't
template <int dim, int spacedim>
inline bool
-TriaAccessor<0, dim, spacedim>::
-operator<(const TriaAccessor<0, dim, spacedim> &other) const
+TriaAccessor<0, dim, spacedim>::operator<(
+ const TriaAccessor<0, dim, spacedim> &other) const
{
Assert(tria == other.tria, TriaAccessorExceptions::ExcCantCompareIterators());
template <int spacedim>
inline bool
-TriaAccessor<0, 1, spacedim>::
-operator<(const TriaAccessor<0, 1, spacedim> &other) const
+TriaAccessor<0, 1, spacedim>::operator<(
+ const TriaAccessor<0, 1, spacedim> &other) const
{
Assert(tria == other.tria, TriaAccessorExceptions::ExcCantCompareIterators());
template <int dim, int spacedim>
bool
- Description<dim, spacedim>::
- operator==(const Description<dim, spacedim> &other) const
+ Description<dim, spacedim>::operator==(
+ const Description<dim, spacedim> &other) const
{
if (this->coarse_cells != other.coarse_cells)
return false;
*
* You must not dereference invalid or past the end iterators.
*/
- const Accessor &operator*() const;
+ const Accessor &
+ operator*() const;
/**
* Dereferencing operator, non-@p const version.
*/
- Accessor &operator*();
+ Accessor &
+ operator*();
/**
* Dereferencing operator, returns a reference of the cell pointed to. Usage
*
* There is a @p const and a non-@p const version.
*/
- const Accessor *operator->() const;
+ const Accessor *
+ operator->() const;
/**
* Dereferencing operator, non-@p const version.
*/
- Accessor *operator->();
+ Accessor *
+ operator->();
/**
template <typename Accessor>
-inline const Accessor &TriaRawIterator<Accessor>::operator*() const
+inline const Accessor &
+TriaRawIterator<Accessor>::operator*() const
{
Assert(Accessor::structure_dimension != Accessor::dimension ||
state() == IteratorState::valid,
template <typename Accessor>
-inline Accessor &TriaRawIterator<Accessor>::operator*()
+inline Accessor &
+TriaRawIterator<Accessor>::operator*()
{
Assert(Accessor::structure_dimension != Accessor::dimension ||
state() == IteratorState::valid,
template <typename Accessor>
-inline const Accessor *TriaRawIterator<Accessor>::operator->() const
+inline const Accessor *
+TriaRawIterator<Accessor>::operator->() const
{
return &(this->operator*());
}
template <typename Accessor>
-inline Accessor *TriaRawIterator<Accessor>::operator->()
+inline Accessor *
+TriaRawIterator<Accessor>::operator->()
{
return &(this->operator*());
}
template <typename Accessor>
inline bool
-TriaRawIterator<Accessor>::
-
operator<(const TriaRawIterator<Accessor> &other) const
+TriaRawIterator<Accessor>::operator<(
+
const TriaRawIterator<Accessor> &other) const
{
Assert(state() != IteratorState::invalid,
ExcDereferenceInvalidObject(accessor));
template <typename Accessor>
inline bool
-TriaRawIterator<Accessor>::
-
operator>(const TriaRawIterator<Accessor> &other) const
+TriaRawIterator<Accessor>::operator>(
+
const TriaRawIterator<Accessor> &other) const
{
return (other < *this);
}
inline
typename std::enable_if<std::is_convertible<OtherAccessor, Accessor>::value,
bool>::type
- TriaRawIterator<Accessor>::
- operator==(const TriaRawIterator<OtherAccessor> &other) const
+ TriaRawIterator<Accessor>::operator==(
+ const TriaRawIterator<OtherAccessor> &other) const
{
return accessor == other.accessor;
}
template <typename Accessor>
inline bool
-TriaRawIterator<Accessor>::
-
operator!=(const TriaRawIterator<Accessor> &other) const
+TriaRawIterator<Accessor>::operator!=(
+
const TriaRawIterator<Accessor> &other) const
{
return !(*this == other);
}
template <typename Accessor>
template <class OtherAccessor>
inline TriaActiveIterator<Accessor> &
-TriaActiveIterator<Accessor>::
-operator=(const TriaActiveIterator<OtherAccessor> &i)
+TriaActiveIterator<Accessor>::operator=(
+ const TriaActiveIterator<OtherAccessor> &i)
{
this->accessor.copy_from(i.accessor);
return *this;
* @pre @p index must be between zero and the number of elements of the
* collection.
*/
- const T &operator[](const unsigned int index) const;
+ const T &
+ operator[](const unsigned int index) const;
/**
* Return the number of objects stored in this container.
template <typename T>
- inline const T &Collection<T>::operator[](const unsigned int index) const
+ inline const T &
+ Collection<T>::operator[](const unsigned int index) const
{
AssertIndexRange(index, entries.size());
return *entries[index];
* from class FiniteElement<dim,spacedim>.
*/
template <class... FETypes>
- explicit FECollection(const FETypes &... fes);
+ explicit FECollection(const FETypes &...fes);
/**
* Constructor. Same as above but for any number of elements. Pointers to
template <int dim, int spacedim>
template <class... FETypes>
- FECollection<dim, spacedim>::FECollection(const FETypes &... fes)
+ FECollection<dim, spacedim>::FECollection(const FETypes &...fes)
{
static_assert(
is_base_of_all<FiniteElement<dim, spacedim>, FETypes...>::value,
template <int dim, int spacedim>
inline bool
- FECollection<dim, spacedim>::
- operator==(const FECollection<dim, spacedim> &fe_collection) const
+ FECollection<dim, spacedim>::operator==(
+ const FECollection<dim, spacedim> &fe_collection) const
{
const unsigned int n_elements = this->size();
if (n_elements != fe_collection.size())
template <int dim, int spacedim>
inline bool
- FECollection<dim, spacedim>::
- operator!=(const FECollection<dim, spacedim> &fe_collection) const
+ FECollection<dim, spacedim>::operator!=(
+ const FECollection<dim, spacedim> &fe_collection) const
{
return !(*this == fe_collection);
}
* from class Mapping<dim,spacedim>.
*/
template <class... MappingTypes>
- explicit MappingCollection(const MappingTypes &... mappings);
+ explicit MappingCollection(const MappingTypes &...mappings);
/**
* Add a new mapping to the MappingCollection. Generally, you will
template <int dim, int spacedim>
template <class... MappingTypes>
MappingCollection<dim, spacedim>::MappingCollection(
- const MappingTypes &... mappings)
+ const MappingTypes &...mappings)
{
static_assert(
is_base_of_all<Mapping<dim, spacedim>, MappingTypes...>::value,
* from class Quadrature<dim>.
*/
template <class... QTypes>
- explicit QCollection(const QTypes &... quadrature_objects);
+ explicit QCollection(const QTypes &...quadrature_objects);
/**
* Add a new quadrature rule to the QCollection. In most cases, you will
template <int dim>
template <class... QTypes>
- QCollection<dim>::QCollection(const QTypes &... quadrature_objects)
+ QCollection<dim>::QCollection(const QTypes &...quadrature_objects)
{
// loop over all of the given arguments and add the quadrature objects to
// this collection. Inlining the definition of q_pointers causes internal
{
template <int dim>
inline void
- points_and_values(Table<2, double> & result,
- const FEValuesBase<dim> & fe,
- const ArrayView<const std::vector<double>> &input)
+ points_and_values(Table<2, double> & result,
+ const FEValuesBase<dim> & fe,
+ const ArrayView<const std::vector<double>> &input)
{
const unsigned int n_comp = fe.get_fe().n_components();
AssertVectorVectorDimension(input, n_comp, fe.n_quadrature_points);
template <typename number>
template <typename ConstraintLineType>
inline typename AffineConstraints<number>::ConstraintLine &
-AffineConstraints<number>::ConstraintLine::
-operator=(const ConstraintLineType &other)
+AffineConstraints<number>::ConstraintLine::operator=(
+ const ConstraintLineType &other)
{
this->index = other.index;
template <typename number>
bool
-AffineConstraints<number>::ConstraintLine::
-operator<(const ConstraintLine &a) const
+AffineConstraints<number>::ConstraintLine::operator<(
+ const ConstraintLine &a) const
{
return index < a.index;
}
template <typename number>
bool
-AffineConstraints<number>::ConstraintLine::
-operator==(const ConstraintLine &a) const
+AffineConstraints<number>::ConstraintLine::operator==(
+ const ConstraintLine &a) const
{
return index == a.index;
}
/**
* Dereferencing operator.
*/
- ScratchData<number> &operator*()
+ ScratchData<number> &
+ operator*()
{
return *my_scratch_data;
}
/**
* Dereferencing operator.
*/
- ScratchData<number> *operator->()
+ ScratchData<number> *
+ operator->()
{
return my_scratch_data;
}
* is <tt>true</tt>, then no writing to the result is possible, making
* this a const_iterator.
*/
- dereference_type operator*() const;
+ dereference_type
+ operator*() const;
/**
* Random access operator, grant access to arbitrary elements relative
* to the one presently pointed to.
*/
- dereference_type operator[](const difference_type d) const;
+ dereference_type
+ operator[](const difference_type d) const;
/**
* Prefix increment operator. This operator advances the iterator to the
*
* Exactly the same as operator().
*/
- value_type operator[](const size_type i) const;
+ value_type
+ operator[](const size_type i) const;
/**
* Access components, returns U(i) as a writeable reference.
*
* Exactly the same as operator().
*/
- reference operator[](const size_type i);
+ reference
+ operator[](const size_type i);
/**
* Instead of getting individual elements of a vector via operator(),
/**
* $U = U * V$: scalar product.
*/
- value_type operator*(const BlockVectorBase &V) const;
+ value_type
+ operator*(const BlockVectorBase &V) const;
/**
* Return the square of the $l_2$-norm.
template <class BlockVectorType, bool Constness>
inline typename Iterator<BlockVectorType, Constness>::dereference_type
- Iterator<BlockVectorType, Constness>::operator*() const
+ Iterator<BlockVectorType, Constness>::operator*() const
{
return parent->block(current_block)(index_within_block);
}
template <class BlockVectorType, bool Constness>
inline typename Iterator<BlockVectorType, Constness>::dereference_type
- Iterator<BlockVectorType, Constness>::
- operator[](const difference_type d) const
+ Iterator<BlockVectorType, Constness>::operator[](
+ const difference_type d) const
{
// if the index pointed to is
// still within the block we
template <class BlockVectorType, bool Constness>
template <bool OtherConstness>
inline bool
- Iterator<BlockVectorType, Constness>::
- operator==(const Iterator<BlockVectorType, OtherConstness> &i) const
+ Iterator<BlockVectorType, Constness>::operator==(
+ const Iterator<BlockVectorType, OtherConstness> &i) const
{
Assert(parent == i.parent, ExcPointerToDifferentVectors());
template <class BlockVectorType, bool Constness>
template <bool OtherConstness>
inline bool
- Iterator<BlockVectorType, Constness>::
- operator!=(const Iterator<BlockVectorType, OtherConstness> &i) const
+ Iterator<BlockVectorType, Constness>::operator!=(
+ const Iterator<BlockVectorType, OtherConstness> &i) const
{
Assert(parent == i.parent, ExcPointerToDifferentVectors());
template <class BlockVectorType, bool Constness>
template <bool OtherConstness>
inline bool
- Iterator<BlockVectorType, Constness>::
- operator<(const Iterator<BlockVectorType, OtherConstness> &i) const
+ Iterator<BlockVectorType, Constness>::operator<(
+ const Iterator<BlockVectorType, OtherConstness> &i) const
{
Assert(parent == i.parent, ExcPointerToDifferentVectors());
template <class BlockVectorType, bool Constness>
template <bool OtherConstness>
inline bool
- Iterator<BlockVectorType, Constness>::
- operator<=(const Iterator<BlockVectorType, OtherConstness> &i) const
+ Iterator<BlockVectorType, Constness>::operator<=(
+ const Iterator<BlockVectorType, OtherConstness> &i) const
{
Assert(parent == i.parent, ExcPointerToDifferentVectors());
template <class BlockVectorType, bool Constness>
template <bool OtherConstness>
inline bool
- Iterator<BlockVectorType, Constness>::
- operator>(const Iterator<BlockVectorType, OtherConstness> &i) const
+ Iterator<BlockVectorType, Constness>::operator>(
+ const Iterator<BlockVectorType, OtherConstness> &i) const
{
Assert(parent == i.parent, ExcPointerToDifferentVectors());
template <class BlockVectorType, bool Constness>
template <bool OtherConstness>
inline bool
- Iterator<BlockVectorType, Constness>::
- operator>=(const Iterator<BlockVectorType, OtherConstness> &i) const
+ Iterator<BlockVectorType, Constness>::operator>=(
+ const Iterator<BlockVectorType, OtherConstness> &i) const
{
Assert(parent == i.parent, ExcPointerToDifferentVectors());
template <class BlockVectorType, bool Constness>
template <bool OtherConstness>
inline typename Iterator<BlockVectorType, Constness>::difference_type
- Iterator<BlockVectorType, Constness>::
- operator-(const Iterator<BlockVectorType, OtherConstness> &i) const
+ Iterator<BlockVectorType, Constness>::operator-(
+ const Iterator<BlockVectorType, OtherConstness> &i) const
{
Assert(parent == i.parent, ExcPointerToDifferentVectors());
template <class BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness>
- Iterator<BlockVectorType, Constness>::
- operator+(const difference_type &d) const
+ Iterator<BlockVectorType, Constness>::operator+(
+ const difference_type &d) const
{
// if the index pointed to is
// still within the block we
template <class BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness>
- Iterator<BlockVectorType, Constness>::
- operator-(const difference_type &d) const
+ Iterator<BlockVectorType, Constness>::operator-(
+ const difference_type &d) const
{
// if the index pointed to is
// still within the block we
template <class VectorType>
-typename BlockVectorBase<VectorType>::value_type BlockVectorBase<VectorType>::
- operator*(const BlockVectorBase<VectorType> &v) const
+typename BlockVectorBase<VectorType>::value_type
+BlockVectorBase<VectorType>::operator*(
+ const BlockVectorBase<VectorType> &v) const
{
Assert(n_blocks() == v.n_blocks(),
ExcDimensionMismatch(n_blocks(), v.n_blocks()));
template <class VectorType>
template <class VectorType2>
inline bool
-BlockVectorBase<VectorType>::
-operator==(const BlockVectorBase<VectorType2> &v) const
+BlockVectorBase<VectorType>::operator==(
+ const BlockVectorBase<VectorType2> &v) const
{
Assert(block_indices == v.block_indices, ExcDifferentBlockIndices());
template <class VectorType>
inline typename BlockVectorBase<VectorType>::value_type
- BlockVectorBase<VectorType>::operator[](const size_type i) const
+BlockVectorBase<VectorType>::operator[](const size_type i) const
{
return operator()(i);
}
template <class VectorType>
inline typename BlockVectorBase<VectorType>::reference
- BlockVectorBase<VectorType>::operator[](const size_type i)
+BlockVectorBase<VectorType>::operator[](const size_type i)
{
return operator()(i);
}
/**
* Dereferencing operator.
*/
- const Accessor<number, Constness> &operator*() const;
+ const Accessor<number, Constness> &
+ operator*() const;
/**
* Dereferencing operator.
*/
- const Accessor<number, Constness> *operator->() const;
+ const Accessor<number, Constness> *
+ operator->() const;
/**
* Comparison. True, if both iterators point to the same matrix position.
template <typename number, bool Constness>
- inline const Accessor<number, Constness> &Iterator<number, Constness>::
- operator*() const
+ inline const Accessor<number, Constness> &
+ Iterator<number, Constness>::operator*() const
{
return accessor;
}
template <typename number, bool Constness>
- inline const Accessor<number, Constness> *Iterator<number, Constness>::
- operator->() const
+ inline const Accessor<number, Constness> *
+ Iterator<number, Constness>::operator->() const
{
return &accessor;
}
/**
* Dereferencing operator.
*/
- const Accessor &operator*() const;
+ const Accessor &
+ operator*() const;
/**
* Dereferencing operator.
*/
- const Accessor *operator->() const;
+ const Accessor *
+ operator->() const;
/**
* Comparison. True, if both iterators point to the same matrix position.
- inline const Accessor &Iterator::operator*() const
+ inline const Accessor &
+ Iterator::operator*() const
{
return accessor;
}
- inline const Accessor *Iterator::operator->() const
+ inline const Accessor *
+ Iterator::operator->() const
{
return &accessor;
}
template <typename Number>
__device__ Number
- ElemSum<Number>::reduction_op(const Number a, const Number b)
+ ElemSum<Number>::reduction_op(const Number a, const Number b)
{
return (a + b);
}
template <typename Number>
__device__ Number
- ElemSum<Number>::atomic_op(Number *dst, const Number a)
+ ElemSum<Number>::atomic_op(Number *dst, const Number a)
{
return atomicAdd(dst, a);
}
template <typename Number>
__device__ Number
- ElemSum<Number>::element_wise_op(const Number a)
+ ElemSum<Number>::element_wise_op(const Number a)
{
return a;
}
template <typename Number>
__device__ Number
- ElemSum<Number>::null_value()
+ ElemSum<Number>::null_value()
{
return Number();
}
template <typename Number>
__device__ Number
- L1Norm<Number>::reduction_op(const Number a, const Number b)
+ L1Norm<Number>::reduction_op(const Number a, const Number b)
{
return (a + b);
}
template <typename Number>
__device__ Number
- L1Norm<Number>::atomic_op(Number *dst, const Number a)
+ L1Norm<Number>::atomic_op(Number *dst, const Number a)
{
return atomicAdd(dst, a);
}
template <typename Number>
__device__ Number
- L1Norm<Number>::element_wise_op(const Number a)
+ L1Norm<Number>::element_wise_op(const Number a)
{
return std::fabs(a);
}
template <typename Number>
__device__ Number
- L1Norm<Number>::null_value()
+ L1Norm<Number>::null_value()
{
return Number();
}
template <typename Number>
__device__ Number
- LInfty<Number>::reduction_op(const Number a, const Number b)
+ LInfty<Number>::reduction_op(const Number a, const Number b)
{
if (a > b)
return a;
template <typename Number>
__device__ Number
- LInfty<Number>::atomic_op(Number *dst, const Number a)
+ LInfty<Number>::atomic_op(Number *dst, const Number a)
{
return atomicMax_wrapper(dst, a);
}
template <typename Number>
__device__ Number
- LInfty<Number>::element_wise_op(const Number a)
+ LInfty<Number>::element_wise_op(const Number a)
{
return std::fabs(a);
}
template <typename Number>
__device__ Number
- LInfty<Number>::null_value()
+ LInfty<Number>::null_value()
{
return Number();
}
template <typename Number>
__device__ Number
- DotProduct<Number>::binary_op(const Number a, const Number b)
+ DotProduct<Number>::binary_op(const Number a, const Number b)
{
return a * b;
}
template <typename Number>
__device__ Number
- DotProduct<Number>::reduction_op(const Number a, const Number b)
+ DotProduct<Number>::reduction_op(const Number a, const Number b)
{
return a + b;
}
template <typename Number>
__device__ Number
- DotProduct<Number>::atomic_op(Number *dst, const Number a)
+ DotProduct<Number>::atomic_op(Number *dst, const Number a)
{
return atomicAdd(dst, a);
}
template <typename Number>
__device__ Number
- DotProduct<Number>::null_value()
+ DotProduct<Number>::null_value()
{
return Number();
}
/**
* Dereferencing operator.
*/
- const Accessor &operator*() const;
+ const Accessor &
+ operator*() const;
/**
* Dereferencing operator.
*/
- const Accessor *operator->() const;
+ const Accessor *
+ operator->() const;
/**
* Comparison. True, if both iterators point to the same matrix position.
- inline const Accessor &Iterator::operator*() const
+ inline const Accessor &
+ Iterator::operator*() const
{
return accessor;
}
- inline const Accessor *Iterator::operator->() const
+ inline const Accessor *
+ Iterator::operator->() const
{
return &accessor;
}
* matrix coincide.
*/
template <int dim>
- void copy_to(Tensor<2, dim> & T,
- const size_type src_r_i = 0,
- const size_type src_r_j = dim - 1,
- const size_type src_c_i = 0,
- const size_type src_c_j = dim - 1,
- const unsigned int dst_r = 0,
- const unsigned int dst_c = 0) const;
+ void
+ copy_to(Tensor<2, dim> & T,
+ const size_type src_r_i = 0,
+ const size_type src_r_j = dim - 1,
+ const size_type src_c_i = 0,
+ const size_type src_c_j = dim - 1,
+ const unsigned int dst_r = 0,
+ const unsigned int dst_c = 0) const;
/**
* Copy a subset of the rows and columns of another matrix into the current
template <typename number>
template <int dim>
-void FullMatrix<number>::copy_to(Tensor<2, dim> & T,
- const size_type src_r_i,
- const size_type src_r_j,
- const size_type src_c_i,
- const size_type src_c_j,
- const unsigned int dst_r,
- const unsigned int dst_c) const
+void
+FullMatrix<number>::copy_to(Tensor<2, dim> & T,
+ const size_type src_r_i,
+ const size_type src_r_j,
+ const size_type src_c_i,
+ const size_type src_c_j,
+ const unsigned int dst_r,
+ const unsigned int dst_c) const
{
Assert(!this->empty(), ExcEmptyMatrix());
AssertIndexRange(src_r_j - src_r_i, dim - dst_r);
template <typename Number>
BlockVector<Number> &
- BlockVector<Number>::
- operator=(const PETScWrappers::MPI::BlockVector &petsc_vec)
+ BlockVector<Number>::operator=(
+ const PETScWrappers::MPI::BlockVector &petsc_vec)
{
AssertDimension(this->n_blocks(), petsc_vec.n_blocks());
for (unsigned int i = 0; i < this->n_blocks(); ++i)
template <typename Number>
BlockVector<Number> &
- BlockVector<Number>::
- operator=(const TrilinosWrappers::MPI::BlockVector &trilinos_vec)
+ BlockVector<Number>::operator=(
+ const TrilinosWrappers::MPI::BlockVector &trilinos_vec)
{
AssertDimension(this->n_blocks(), trilinos_vec.n_blocks());
for (unsigned int i = 0; i < this->n_blocks(); ++i)
template <typename Number>
- Number BlockVector<Number>::
- operator*(const VectorSpaceVector<Number> &vv) const
+ Number
+ BlockVector<Number>::operator*(const VectorSpaceVector<Number> &vv) const
{
Assert(this->n_blocks() > 0, ExcEmptyObject());
*
* This function does the same thing as operator().
*/
- Number operator[](const size_type global_index) const;
+ Number
+ operator[](const size_type global_index) const;
/**
* Read and write access to the data in the position corresponding to @p
* global_index. The index must be either in the local range of the
*
* This function does the same thing as operator().
*/
- Number &operator[](const size_type global_index);
+ Number &
+ operator[](const size_type global_index);
/**
* Read access to the data field specified by @p local_index. Locally
template <typename Number, typename MemorySpace>
- inline Number Vector<Number, MemorySpace>::
- operator[](const size_type global_index) const
+ inline Number
+ Vector<Number, MemorySpace>::operator[](const size_type global_index) const
{
return operator()(global_index);
}
template <typename Number, typename MemorySpace>
- inline Number &Vector<Number, MemorySpace>::
- operator[](const size_type global_index)
+ inline Number &
+ Vector<Number, MemorySpace>::operator[](const size_type global_index)
{
return operator()(global_index);
}
template <typename Number, typename MemorySpaceType>
inline Vector<Number, MemorySpaceType> &
- Vector<Number, MemorySpaceType>::
- operator=(const Vector<Number, MemorySpaceType> &c)
+ Vector<Number, MemorySpaceType>::operator=(
+ const Vector<Number, MemorySpaceType> &c)
{
#ifdef _MSC_VER
return this->operator=<Number>(c);
template <typename Number, typename MemorySpaceType>
template <typename Number2>
inline Vector<Number, MemorySpaceType> &
- Vector<Number, MemorySpaceType>::
- operator=(const Vector<Number2, MemorySpaceType> &c)
+ Vector<Number, MemorySpaceType>::operator=(
+ const Vector<Number2, MemorySpaceType> &c)
{
Assert(c.partitioner.get() != nullptr, ExcNotInitialized());
template <typename Number, typename MemorySpaceType>
Vector<Number, MemorySpaceType> &
- Vector<Number, MemorySpaceType>::
- operator+=(const VectorSpaceVector<Number> &vv)
+ Vector<Number, MemorySpaceType>::operator+=(
+ const VectorSpaceVector<Number> &vv)
{
// Downcast. Throws an exception if invalid.
using VectorType = Vector<Number, MemorySpaceType>;
template <typename Number, typename MemorySpaceType>
Vector<Number, MemorySpaceType> &
- Vector<Number, MemorySpaceType>::
- operator-=(const VectorSpaceVector<Number> &vv)
+ Vector<Number, MemorySpaceType>::operator-=(
+ const VectorSpaceVector<Number> &vv)
{
// Downcast. Throws an exception if invalid.
using VectorType = Vector<Number, MemorySpaceType>;
template <typename Number, typename MemorySpaceType>
- Number Vector<Number, MemorySpaceType>::
- operator*(const VectorSpaceVector<Number> &vv) const
+ Number
+ Vector<Number, MemorySpaceType>::operator*(
+ const VectorSpaceVector<Number> &vv) const
{
// Downcast. Throws an exception if invalid.
using VectorType = Vector<Number, MemorySpaceType>;
/**
* Return the scalar product of two vectors.
*/
- virtual Number operator*(const VectorSpaceVector<Number> &V) const override;
+ virtual Number
+ operator*(const VectorSpaceVector<Number> &V) const override;
/**
* This function is not implemented and will throw an exception.
{
size_type current_size = this->size();
ar &static_cast<Subscriptor &>(*this);
- ar & this->stored_elements;
+ ar &this->stored_elements;
// If necessary, resize the vector during a read operation
if (this->size() != current_size)
this->reinit(this->size());
template <typename Number>
- Number Vector<Number>::operator*(const VectorSpaceVector<Number> &V) const
+ Number
+ Vector<Number>::operator*(const VectorSpaceVector<Number> &V) const
{
// Check that casting will work.
Assert(dynamic_cast<const Vector<Number> *>(&V) != nullptr,
* Operator that returns a payload configured to support the
* multiplication of two LinearOperators
*/
- inline EmptyPayload operator*(const EmptyPayload &, const EmptyPayload &)
+ inline EmptyPayload
+ operator*(const EmptyPayload &, const EmptyPayload &)
{
return {};
}
/**
* Dereferencing operator.
*/
- const ACCESSOR &operator*() const;
+ const ACCESSOR &
+ operator*() const;
/**
* Dereferencing operator.
*/
- const ACCESSOR *operator->() const;
+ const ACCESSOR *
+ operator->() const;
/**
* Comparison. True, if both accessors are equal.
template <class ACCESSOR>
-inline const ACCESSOR &MatrixIterator<ACCESSOR>::operator*() const
+inline const ACCESSOR &
+MatrixIterator<ACCESSOR>::operator*() const
{
return accessor;
}
template <class ACCESSOR>
-inline const ACCESSOR *MatrixIterator<ACCESSOR>::operator->() const
+inline const ACCESSOR *
+MatrixIterator<ACCESSOR>::operator->() const
{
return &accessor;
}
* @ingroup LAOperators
*/
template <typename Range>
-PackagedOperation<Range> operator*(const PackagedOperation<Range> &comp,
- typename Range::value_type number)
+PackagedOperation<Range>
+operator*(const PackagedOperation<Range> &comp,
+ typename Range::value_type number)
{
PackagedOperation<Range> return_comp;
* @ingroup LAOperators
*/
template <typename Range>
-PackagedOperation<Range> operator*(typename Range::value_type number,
- const PackagedOperation<Range> &comp)
+PackagedOperation<Range>
+operator*(typename Range::value_type number,
+ const PackagedOperation<Range> &comp)
{
return comp * number;
}
typename = typename std::enable_if<
internal::PackagedOperationImplementation::has_vector_interface<
Range>::type::value>::type>
-PackagedOperation<Range> operator*(const Range & u,
- typename Range::value_type number)
+PackagedOperation<Range>
+operator*(const Range &u, typename Range::value_type number)
{
return PackagedOperation<Range>(u) * number;
}
typename = typename std::enable_if<
internal::PackagedOperationImplementation::has_vector_interface<
Range>::type::value>::type>
-PackagedOperation<Range> operator*(typename Range::value_type number,
- const Range & u)
+PackagedOperation<Range>
+operator*(typename Range::value_type number, const Range &u)
{
return number * PackagedOperation<Range>(u);
}
/**
* Dereferencing operator.
*/
- const Accessor &operator*() const;
+ const Accessor &
+ operator*() const;
/**
* Dereferencing operator.
*/
- const Accessor *operator->() const;
+ const Accessor *
+ operator->() const;
/**
* Comparison. True, if both iterators point to the same matrix
}
- inline const const_iterator::Accessor &const_iterator::operator*() const
+ inline const const_iterator::Accessor &
+ const_iterator::operator*() const
{
return accessor;
}
- inline const const_iterator::Accessor *const_iterator::operator->() const
+ inline const const_iterator::Accessor *
+ const_iterator::operator->() const
{
return &accessor;
}
*
* Exactly the same as operator().
*/
- reference operator[](const size_type index);
+ reference
+ operator[](const size_type index);
/**
* Provide read-only access to an element.
*
* Exactly the same as operator().
*/
- PetscScalar operator[](const size_type index) const;
+ PetscScalar
+ operator[](const size_type index) const;
/**
* A collective set operation: instead of setting individual elements of a
*
* For complex valued vector, this gives$\left(v^\ast,vec\right)$.
*/
- PetscScalar operator*(const VectorBase &vec) const;
+ PetscScalar
+ operator*(const VectorBase &vec) const;
/**
* Return the square of the $l_2$-norm.
- inline internal::VectorReference VectorBase::operator[](const size_type index)
+ inline internal::VectorReference
+ VectorBase::operator[](const size_type index)
{
return operator()(index);
}
- inline PetscScalar VectorBase::operator[](const size_type index) const
+ inline PetscScalar
+ VectorBase::operator[](const size_type index) const
{
return operator()(index);
}
inline typename PreconditionChebyshev<MatrixType,
VectorType,
PreconditionerType>::AdditionalData &
- PreconditionChebyshev<MatrixType, VectorType, PreconditionerType>::
+PreconditionChebyshev<MatrixType, VectorType, PreconditionerType>::
AdditionalData::operator=(const AdditionalData &other_data)
{
degree = other_data.degree;
/**
* Dereferencing operator.
*/
- const Accessor &operator*() const;
+ const Accessor &
+ operator*() const;
/**
* Dereferencing operator.
*/
- const Accessor *operator->() const;
+ const Accessor *
+ operator->() const;
/**
* Comparison. True, if both iterators point to the same matrix position.
template <typename MatrixType, typename inverse_type>
-inline
- typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator &
- PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
- operator++()
+inline typename PreconditionBlockJacobi<MatrixType,
+ inverse_type>::const_iterator &
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::operator++()
{
Assert(*this != accessor.matrix->end(), ExcIteratorPastEnd());
template <typename MatrixType, typename inverse_type>
inline const typename PreconditionBlockJacobi<MatrixType, inverse_type>::
const_iterator::Accessor &
- PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
- operator*() const
+ PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::operator*()
+ const
{
return accessor;
}
template <typename MatrixType, typename inverse_type>
inline const typename PreconditionBlockJacobi<MatrixType, inverse_type>::
const_iterator::Accessor *
- PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
- operator->() const
+ PreconditionBlockJacobi<MatrixType,
+ inverse_type>::const_iterator::operator->() const
{
return &accessor;
}
template <typename MatrixType, typename inverse_type>
inline bool
-PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
-operator==(const const_iterator &other) const
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::operator==(
+ const const_iterator &other) const
{
if (accessor.a_block == accessor.matrix->size() &&
accessor.a_block == other.accessor.a_block)
template <typename MatrixType, typename inverse_type>
inline bool
-PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
-operator!=(const const_iterator &other) const
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::operator!=(
+ const const_iterator &other) const
{
return !(*this == other);
}
template <typename MatrixType, typename inverse_type>
inline bool
-PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
-operator<(const const_iterator &other) const
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::operator<(
+ const const_iterator &other) const
{
return (accessor.row() < other.accessor.row() ||
(accessor.row() == other.accessor.row() &&
const Number rho2 = column_norm_sqr - u.norm_sqr();
const bool linearly_independent =
column_signal.empty() ? rho2 > 0 :
- column_signal(u, rho2, column_norm_sqr).get();
+ column_signal(u, rho2, column_norm_sqr).get();
// bail out if it turns out to be linearly dependent
if (!linearly_independent)
*
* This function does the same thing as operator().
*/
- Number operator[](const size_type global_index) const;
+ Number
+ operator[](const size_type global_index) const;
/**
* Read and write access to the data in the position corresponding to @p
*
* This function does the same thing as operator().
*/
- Number &operator[](const size_type global_index);
+ Number &
+ operator[](const size_type global_index);
/**
* Instead of getting individual elements of a vector via operator(),
template <typename Number>
- inline Number ReadWriteVector<Number>::
- operator[](const size_type global_index) const
+ inline Number
+ ReadWriteVector<Number>::operator[](const size_type global_index) const
{
return operator()(global_index);
}
template <typename Number>
- inline Number &ReadWriteVector<Number>::
- operator[](const size_type global_index)
+ inline Number &
+ ReadWriteVector<Number>::operator[](const size_type global_index)
{
return operator()(global_index);
}
template <typename Number>
template <typename Functor>
void
- ReadWriteVector<Number>::FunctorTemplate<Functor>::
- operator()(const size_type begin, const size_type end)
+ ReadWriteVector<Number>::FunctorTemplate<Functor>::operator()(
+ const size_type begin,
+ const size_type end)
{
for (size_type i = begin; i < end; ++i)
functor(parent.values[i]);
const bool invert_diagonal = true,
const bool same_diagonal = false,
const typename PreconditionBlockBase<InverseNumberType>::Inversion
- inversion = PreconditionBlockBase<InverseNumberType>::gauss_jordan,
+ inversion = PreconditionBlockBase<InverseNumberType>::gauss_jordan,
const double threshold = 0.,
VectorType * temp_ghost_vector = nullptr);
else
{
// compute blocks in parallel
- parallel::apply_to_subranges(0,
- this->additional_data->block_list.n_rows(),
- [this](const size_type block_begin,
- const size_type block_end) {
- this->block_kernel(block_begin, block_end);
- },
- 16);
+ parallel::apply_to_subranges(
+ 0,
+ this->additional_data->block_list.n_rows(),
+ [this](const size_type block_begin, const size_type block_end) {
+ this->block_kernel(block_begin, block_end);
+ },
+ 16);
}
this->inverses_computed(true);
}
template <class VectorType>
inline SolverControl::State
-SolverBase<VectorType>::StateCombiner::
-operator()(const SolverControl::State state1,
- const SolverControl::State state2) const
+SolverBase<VectorType>::StateCombiner::operator()(
+ const SolverControl::State state1,
+ const SolverControl::State state2) const
{
if ((state1 == SolverControl::failure) || (state2 == SolverControl::failure))
return SolverControl::failure;
* Get vector number @p i. If this vector was unused before, an error
* occurs.
*/
- VectorType &operator[](const unsigned int i) const;
+ VectorType &
+ operator[](const unsigned int i) const;
/**
* Get vector number @p i. Allocate it if necessary.
template <class VectorType>
- inline VectorType &TmpVectors<VectorType>::
- operator[](const unsigned int i) const
+ inline VectorType &
+ TmpVectors<VectorType>::operator[](const unsigned int i) const
{
AssertIndexRange(i, data.size());
* Get vector number @p i. If this vector was unused before, an error
* occurs.
*/
- VectorType &operator[](const unsigned int i) const;
+ VectorType &
+ operator[](const unsigned int i) const;
/**
* Get vector number @p i. Allocate it if necessary.
template <class VectorType>
- inline VectorType &TmpVectors<VectorType>::
- operator[](const unsigned int i) const
+ inline VectorType &
+ TmpVectors<VectorType>::operator[](const unsigned int i) const
{
AssertIndexRange(i, data.size());
/**
* Dereferencing operator.
*/
- const Accessor<number, Constness> &operator*() const;
+ const Accessor<number, Constness> &
+ operator*() const;
/**
* Dereferencing operator.
*/
- const Accessor<number, Constness> *operator->() const;
+ const Accessor<number, Constness> *
+ operator->() const;
/**
* Comparison. True, if both iterators point to the same matrix position.
template <typename number, bool Constness>
inline const Iterator<number, Constness> &
- Iterator<number, Constness>::
- operator=(const SparseMatrixIterators::Iterator<number, false> &i)
+ Iterator<number, Constness>::operator=(
+ const SparseMatrixIterators::Iterator<number, false> &i)
{
accessor = *i;
return *this;
template <typename number, bool Constness>
- inline const Accessor<number, Constness> &Iterator<number, Constness>::
- operator*() const
+ inline const Accessor<number, Constness> &
+ Iterator<number, Constness>::operator*() const
{
return accessor;
}
template <typename number, bool Constness>
- inline const Accessor<number, Constness> *Iterator<number, Constness>::
- operator->() const
+ inline const Accessor<number, Constness> *
+ Iterator<number, Constness>::operator->() const
{
return &accessor;
}
/**
* Dereferencing operator.
*/
- const Accessor &operator*() const;
+ const Accessor &
+ operator*() const;
/**
* Dereferencing operator.
*/
- const Accessor *operator->() const;
+ const Accessor *
+ operator->() const;
/**
* Comparison. True, if both iterators point to the same matrix position.
template <typename number>
inline const typename SparseMatrixEZ<number>::const_iterator::Accessor &
- SparseMatrixEZ<number>::const_iterator::operator*() const
+SparseMatrixEZ<number>::const_iterator::operator*() const
{
return accessor;
}
template <typename number>
inline const typename SparseMatrixEZ<number>::const_iterator::Accessor *
- SparseMatrixEZ<number>::const_iterator::operator->() const
+SparseMatrixEZ<number>::const_iterator::operator->() const
{
return &accessor;
}
template <typename number>
inline bool
-SparseMatrixEZ<number>::const_iterator::
-operator==(const const_iterator &other) const
+SparseMatrixEZ<number>::const_iterator::operator==(
+ const const_iterator &other) const
{
return (accessor.row() == other.accessor.row() &&
accessor.index() == other.accessor.index());
template <typename number>
inline bool
-SparseMatrixEZ<number>::const_iterator::
-operator!=(const const_iterator &other) const
+SparseMatrixEZ<number>::const_iterator::operator!=(
+ const const_iterator &other) const
{
return !(*this == other);
}
template <typename number>
inline bool
-SparseMatrixEZ<number>::const_iterator::
-operator<(const const_iterator &other) const
+SparseMatrixEZ<number>::const_iterator::operator<(
+ const const_iterator &other) const
{
return (accessor.row() < other.accessor.row() ||
(accessor.row() == other.accessor.row() &&
/**
* Dereferencing operator.
*/
- const Accessor<Constness> &operator*() const;
+ const Accessor<Constness> &
+ operator*() const;
/**
* Dereferencing operator.
*/
- const Accessor<Constness> *operator->() const;
+ const Accessor<Constness> *
+ operator->() const;
/**
* Comparison. True, if both iterators point to the same matrix
* Return an operator that returns a payload configured to support the
* multiplication of two LinearOperators
*/
- TrilinosPayload operator*(const TrilinosPayload &first_op,
- const TrilinosPayload &second_op);
+ TrilinosPayload
+ operator*(const TrilinosPayload &first_op,
+ const TrilinosPayload &second_op);
} // namespace LinearOperatorImplementation
} /* namespace internal */
template <bool Constness>
- inline const Accessor<Constness> &Iterator<Constness>::operator*() const
+ inline const Accessor<Constness> &
+ Iterator<Constness>::operator*() const
{
return accessor;
}
template <bool Constness>
- inline const Accessor<Constness> *Iterator<Constness>::operator->() const
+ inline const Accessor<Constness> *
+ Iterator<Constness>::operator->() const
{
return &accessor;
}
/**
* Dereferencing operator.
*/
- const Accessor &operator*() const;
+ const Accessor &
+ operator*() const;
/**
* Dereferencing operator.
*/
- const Accessor *operator->() const;
+ const Accessor *
+ operator->() const;
/**
* Comparison. True, if both iterators point to the same matrix
- inline const Accessor &Iterator::operator*() const
+ inline const Accessor &
+ Iterator::operator*() const
{
return accessor;
}
- inline const Accessor *Iterator::operator->() const
+ inline const Accessor *
+ Iterator::operator->() const
{
return &accessor;
}
template <typename Number>
- Number Vector<Number>::operator*(const VectorSpaceVector<Number> &V) const
+ Number
+ Vector<Number>::operator*(const VectorSpaceVector<Number> &V) const
{
// Check that casting will work.
Assert(dynamic_cast<const Vector<Number> *>(&V) != nullptr,
* Return the scalar (inner) product of two vectors. The vectors must have
* the same size.
*/
- TrilinosScalar operator*(const Vector &vec) const;
+ TrilinosScalar
+ operator*(const Vector &vec) const;
/**
* Return the square of the $l_2$-norm.
*
* Exactly the same as operator().
*/
- reference operator[](const size_type index);
+ reference
+ operator[](const size_type index);
/**
* Provide read-only access to an element.
*
* Exactly the same as operator().
*/
- TrilinosScalar operator[](const size_type index) const;
+ TrilinosScalar
+ operator[](const size_type index) const;
/**
* Instead of getting individual elements of a vector via operator(),
- inline internal::VectorReference Vector::operator[](const size_type index)
+ inline internal::VectorReference
+ Vector::operator[](const size_type index)
{
return operator()(index);
}
- inline TrilinosScalar Vector::operator[](const size_type index) const
+ inline TrilinosScalar
+ Vector::operator[](const size_type index) const
{
return operator()(index);
}
- inline TrilinosScalar Vector::operator*(const Vector &vec) const
+ inline TrilinosScalar
+ Vector::operator*(const Vector &vec) const
{
Assert(vector->Map().SameAs(vec.vector->Map()),
ExcDifferentParallelPartitioning());
* repeatable results from one run to another.
*/
template <typename Number2>
- Number operator*(const Vector<Number2> &V) const;
+ Number
+ operator*(const Vector<Number2> &V) const;
/**
* Return the square of the $l_2$-norm.
*
* Exactly the same as operator().
*/
- Number operator[](const size_type i) const;
+ Number
+ operator[](const size_type i) const;
/**
* Access the @p ith component as a writeable reference.
*
* Exactly the same as operator().
*/
- Number &operator[](const size_type i);
+ Number &
+ operator[](const size_type i);
/**
* Instead of getting individual elements of a vector via operator(),
template <typename Number>
-inline Number Vector<Number>::operator[](const size_type i) const
+inline Number
+Vector<Number>::operator[](const size_type i) const
{
return operator()(i);
}
template <typename Number>
-inline Number &Vector<Number>::operator[](const size_type i)
+inline Number &
+Vector<Number>::operator[](const size_type i)
{
return operator()(i);
}
template <typename Number>
template <typename Number2>
-Number Vector<Number>::operator*(const Vector<Number2> &v) const
+Number
+Vector<Number>::operator*(const Vector<Number2> &v) const
{
Assert(size() != 0, ExcEmptyObject());
/**
* Return the scalar product of two vectors.
*/
- virtual Number operator*(const VectorSpaceVector<Number> &V) const = 0;
+ virtual Number
+ operator*(const VectorSpaceVector<Number> &V) const = 0;
/**
* Add @p a to all components. Note that @p a is a scalar not a vector.
__device__ inline unsigned int
compute_index()
{
- return (dim == 1 ?
- threadIdx.x % n_points_1d :
- dim == 2 ?
- threadIdx.x % n_points_1d + n_points_1d * threadIdx.y :
- threadIdx.x % n_points_1d +
- n_points_1d * (threadIdx.y + n_points_1d * threadIdx.z));
+ return (dim == 1 ? threadIdx.x % n_points_1d :
+ dim == 2 ? threadIdx.x % n_points_1d + n_points_1d * threadIdx.y :
+ threadIdx.x % n_points_1d +
+ n_points_1d *
+ (threadIdx.y + n_points_1d * threadIdx.z));
}
} // namespace internal
* id.
*/
__device__ value_type
- get_value() const;
+ get_value() const;
/**
* Same as above, except that the local dof index is computed from the
* thread id.
*/
__device__ value_type
- get_dof_value() const;
+ get_dof_value() const;
/**
* Same as above, except that the quadrature point is computed from the
* thread id.
*/
__device__ gradient_type
- get_gradient() const;
+ get_gradient() const;
/**
* Same as above, except that the quadrature point is computed from the
// time (by virtue of being 'constexpr')
// TODO this function should be rewritten using meta-programming
__host__ __device__ constexpr unsigned int
- cells_per_block_shmem(int dim, int fe_degree)
+ cells_per_block_shmem(int dim, int fe_degree)
{
/* clang-format off */
// We are limiting the number of threads according to the
__device__ inline unsigned int
q_point_id_in_cell(const unsigned int n_q_points_1d)
{
- return (dim == 1 ?
- threadIdx.x % n_q_points_1d :
- dim == 2 ?
- threadIdx.x % n_q_points_1d + n_q_points_1d * threadIdx.y :
- threadIdx.x % n_q_points_1d +
- n_q_points_1d * (threadIdx.y + n_q_points_1d * threadIdx.z));
+ return (
+ dim == 1 ? threadIdx.x % n_q_points_1d :
+ dim == 2 ? threadIdx.x % n_q_points_1d + n_q_points_1d * threadIdx.y :
+ threadIdx.x % n_q_points_1d +
+ n_q_points_1d * (threadIdx.y + n_q_points_1d * threadIdx.z));
}
{
const unsigned int i = (dim == 1) ? 0 : threadIdx.x % n_q_points_1d;
const unsigned int j = (dim == 3) ? threadIdx.y : 0;
- const unsigned int q = (dim == 1) ?
- (threadIdx.x % n_q_points_1d) :
- (dim == 2) ? threadIdx.y : threadIdx.z;
+ const unsigned int q = (dim == 1) ? (threadIdx.x % n_q_points_1d) :
+ (dim == 2) ? threadIdx.y :
+ threadIdx.z;
// This loop simply multiply the shape function at the quadrature point by
// the value finite element coefficient.
const unsigned int shape_idx =
dof_to_quad ? (q + k * n_q_points_1d) : (k + q * n_q_points_1d);
const unsigned int source_idx =
- (direction == 0) ?
- (k + n_q_points_1d * (i + n_q_points_1d * j)) :
- (direction == 1) ? (i + n_q_points_1d * (k + n_q_points_1d * j)) :
- (i + n_q_points_1d * (j + n_q_points_1d * k));
+ (direction == 0) ? (k + n_q_points_1d * (i + n_q_points_1d * j)) :
+ (direction == 1) ? (i + n_q_points_1d * (k + n_q_points_1d * j)) :
+ (i + n_q_points_1d * (j + n_q_points_1d * k));
t += shape_data[shape_idx] *
(in_place ? out[source_idx] : in[source_idx]);
}
__syncthreads();
const unsigned int destination_idx =
- (direction == 0) ?
- (q + n_q_points_1d * (i + n_q_points_1d * j)) :
- (direction == 1) ? (i + n_q_points_1d * (q + n_q_points_1d * j)) :
- (i + n_q_points_1d * (j + n_q_points_1d * q));
+ (direction == 0) ? (q + n_q_points_1d * (i + n_q_points_1d * j)) :
+ (direction == 1) ? (i + n_q_points_1d * (q + n_q_points_1d * j)) :
+ (i + n_q_points_1d * (j + n_q_points_1d * q));
if (add)
out[destination_idx] += t;
*
* @ref EvaluationFlags
*/
- inline EvaluationFlags operator&(const EvaluationFlags f1,
- const EvaluationFlags f2)
+ inline EvaluationFlags
+ operator&(const EvaluationFlags f1, const EvaluationFlags f2)
{
return static_cast<EvaluationFlags>(static_cast<unsigned int>(f1) &
static_cast<unsigned int>(f2));
n_points_1d,
0);
- const unsigned int in_stride = do_evaluate ?
- dofs_per_component_on_cell :
- dofs_per_component_on_face;
+ const unsigned int in_stride = do_evaluate ?
+ dofs_per_component_on_cell :
+ dofs_per_component_on_face;
const unsigned int out_stride = do_evaluate ?
dofs_per_component_on_face :
dofs_per_component_on_cell;
bool
instantiation_helper_run(const unsigned int given_degree,
const unsigned int n_q_points_1d,
- Args &... args)
+ Args &...args)
{
if (given_degree == degree)
{
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE Tensor<1, dim, VectorizedArrayType>
- FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
+FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
get_normal_vector(const unsigned int q_point) const
{
AssertIndexRange(q_point, n_quadrature_points);
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
- FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::JxW(
+FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::JxW(
const unsigned int q_point) const
{
AssertIndexRange(q_point, n_quadrature_points);
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE Tensor<2, dim, VectorizedArrayType>
- FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
+FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
inverse_jacobian(const unsigned int q_point) const
{
AssertIndexRange(q_point, n_quadrature_points);
bool is_face,
typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE Tensor<1, n_components_, VectorizedArrayType>
- FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
+FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
get_dof_value(const unsigned int dof) const
{
AssertIndexRange(dof, this->data->dofs_per_component_on_cell);
bool is_face,
typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE Tensor<1, n_components_, VectorizedArrayType>
- FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
+FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
get_value(const unsigned int q_point) const
{
# ifdef DEBUG
bool is_face,
typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE Tensor<1, n_components_, VectorizedArrayType>
- FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
+FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
get_normal_derivative(const unsigned int q_point) const
{
AssertIndexRange(q_point, this->n_quadrature_points);
FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::operator=(
const FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType> &other)
{
- this->FEEvaluationBase<dim, 1, Number, is_face, VectorizedArrayType>::
- operator=(other);
+ this
+ ->FEEvaluationBase<dim, 1, Number, is_face, VectorizedArrayType>::operator=(
+ other);
return *this;
}
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
- FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::get_dof_value(
+FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::get_dof_value(
const unsigned int dof) const
{
AssertIndexRange(dof, this->data->dofs_per_component_on_cell);
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
- FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::get_value(
+FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::get_value(
const unsigned int q_point) const
{
# ifdef DEBUG
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
- FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::
+FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::
get_normal_derivative(const unsigned int q_point) const
{
return BaseClass::get_normal_derivative(q_point)[0];
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE Tensor<1, dim, VectorizedArrayType>
- FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::get_gradient(
+FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::get_gradient(
const unsigned int q_point) const
{
// could use the base class gradient, but that involves too many expensive
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline void DEAL_II_ALWAYS_INLINE
- FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::
+FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::
submit_dof_value(const VectorizedArrayType val_in, const unsigned int dof)
{
# ifdef DEBUG
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline void DEAL_II_ALWAYS_INLINE
- FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::submit_value(
+FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>::submit_value(
const VectorizedArrayType val_in,
const unsigned int q_point)
{
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE Tensor<2, dim, VectorizedArrayType>
- FEEvaluationAccess<dim, dim, Number, is_face, VectorizedArrayType>::
+FEEvaluationAccess<dim, dim, Number, is_face, VectorizedArrayType>::
get_gradient(const unsigned int q_point) const
{
return BaseClass::get_gradient(q_point);
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
- FEEvaluationAccess<dim, dim, Number, is_face, VectorizedArrayType>::
+FEEvaluationAccess<dim, dim, Number, is_face, VectorizedArrayType>::
get_divergence(const unsigned int q_point) const
{
# ifdef DEBUG
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, VectorizedArrayType>
- FEEvaluationAccess<dim, dim, Number, is_face, VectorizedArrayType>::
+FEEvaluationAccess<dim, dim, Number, is_face, VectorizedArrayType>::
get_symmetric_gradient(const unsigned int q_point) const
{
// copy from generic function into dim-specialization function
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE Tensor<2, dim, VectorizedArrayType>
- FEEvaluationAccess<dim, dim, Number, is_face, VectorizedArrayType>::
+FEEvaluationAccess<dim, dim, Number, is_face, VectorizedArrayType>::
get_hessian_diagonal(const unsigned int q_point) const
{
return BaseClass::get_hessian_diagonal(q_point);
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE Tensor<3, dim, VectorizedArrayType>
- FEEvaluationAccess<dim, dim, Number, is_face, VectorizedArrayType>::get_hessian(
+FEEvaluationAccess<dim, dim, Number, is_face, VectorizedArrayType>::get_hessian(
const unsigned int q_point) const
{
# ifdef DEBUG
template <typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
- FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::get_dof_value(
+FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::get_dof_value(
const unsigned int dof) const
{
AssertIndexRange(dof, this->data->dofs_per_component_on_cell);
template <typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
- FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::get_value(
+FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::get_value(
const unsigned int q_point) const
{
# ifdef DEBUG
template <typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE Tensor<1, 1, VectorizedArrayType>
- FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::get_gradient(
+FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::get_gradient(
const unsigned int q_point) const
{
// could use the base class gradient, but that involves too many inefficient
template <typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
- FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::get_divergence(
+FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::get_divergence(
const unsigned int q_point) const
{
return get_gradient(q_point)[0];
template <typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
- FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::
+FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::
get_normal_derivative(const unsigned int q_point) const
{
return BaseClass::get_normal_derivative(q_point)[0];
template <typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE Tensor<2, 1, VectorizedArrayType>
- FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::get_hessian(
+FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::get_hessian(
const unsigned int q_point) const
{
return BaseClass::get_hessian(q_point)[0];
template <typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE Tensor<1, 1, VectorizedArrayType>
- FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::
+FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::
get_hessian_diagonal(const unsigned int q_point) const
{
return BaseClass::get_hessian_diagonal(q_point)[0];
template <typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
- FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::get_laplacian(
+FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::get_laplacian(
const unsigned int q_point) const
{
return BaseClass::get_laplacian(q_point)[0];
template <typename Number, bool is_face, typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE void DEAL_II_ALWAYS_INLINE
- FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::
+FEEvaluationAccess<1, 1, Number, is_face, VectorizedArrayType>::
submit_dof_value(const VectorizedArrayType val_in, const unsigned int dof)
{
# ifdef DEBUG
result[i][d] = value[d][i][vector_lane];
}
- static void get_gradient(
+ static void
+ get_gradient(
Tensor<1, dim, Tensor<1, n_components, VectorizedArray<Number>>> &value,
const unsigned int vector_lane,
const gradient_type &result)
}
static void
- get_value(Tensor<1, n_components, VectorizedArray<Number>> &value,
- const unsigned int vector_lane,
- const value_type & result)
+ get_value(Tensor<1, n_components, VectorizedArray<Number>> &value,
+ const unsigned int vector_lane,
+ const value_type & result)
{
for (unsigned int i = 0; i < n_components; ++i)
value[i][vector_lane] = result[i];
}
template <typename Number2>
- static Number2 &access(Tensor<1, n_components, Number2> &value,
- const unsigned int component)
+ static Number2 &
+ access(Tensor<1, n_components, Number2> &value,
+ const unsigned int component)
{
return value[component];
}
result[d] = value[d][vector_lane];
}
- static void get_gradient(Tensor<1, dim, VectorizedArray<Number>> &value,
- const unsigned int vector_lane,
- const gradient_type &result)
+ static void
+ get_gradient(Tensor<1, dim, VectorizedArray<Number>> &value,
+ const unsigned int vector_lane,
+ const gradient_type & result)
{
for (unsigned int d = 0; d < dim; ++d)
value[d][vector_lane] = result[d];
result[i][d] = value[d][i][vector_lane];
}
- static void get_gradient(
+ static void
+ get_gradient(
Tensor<1, dim, Tensor<1, dim, VectorizedArray<Number>>> &value,
const unsigned int vector_lane,
const gradient_type & result)
result[i] = value[i][vector_lane];
}
- static void get_value(Tensor<1, dim, VectorizedArray<Number>> &value,
- const unsigned int vector_lane,
- const value_type & result)
+ static void
+ get_value(Tensor<1, dim, VectorizedArray<Number>> &value,
+ const unsigned int vector_lane,
+ const value_type & result)
{
for (unsigned int i = 0; i < dim; ++i)
value[i][vector_lane] = result[i];
result[0] = value[0][vector_lane];
}
- static void get_gradient(Tensor<1, 1, VectorizedArray<Number>> &value,
- const unsigned int vector_lane,
- const gradient_type &result)
+ static void
+ get_gradient(Tensor<1, 1, VectorizedArray<Number>> &value,
+ const unsigned int vector_lane,
+ const gradient_type & result)
{
value[0][vector_lane] = result[0];
}
if (local_line < 8)
{
- x =
- (local_line % 4 == 0) ? 0 : (local_line % 4 == 1) ? fe_degree : dof;
- y =
- (local_line % 4 == 2) ? 0 : (local_line % 4 == 3) ? fe_degree : dof;
+ x = (local_line % 4 == 0) ? 0 :
+ (local_line % 4 == 1) ? fe_degree :
+ dof;
+ y = (local_line % 4 == 2) ? 0 :
+ (local_line % 4 == 3) ? fe_degree :
+ dof;
z = (local_line / 4) * fe_degree;
}
else
const unsigned int this_type =
(direction == 0) ?
dealii::internal::MatrixFreeFunctions::ConstraintTypes::type_x :
- (direction == 1) ?
+ (direction == 1) ?
dealii::internal::MatrixFreeFunctions::ConstraintTypes::type_y :
dealii::internal::MatrixFreeFunctions::ConstraintTypes::type_z;
const unsigned int face1_type =
(direction == 0) ?
dealii::internal::MatrixFreeFunctions::ConstraintTypes::type_y :
- (direction == 1) ?
+ (direction == 1) ?
dealii::internal::MatrixFreeFunctions::ConstraintTypes::type_z :
dealii::internal::MatrixFreeFunctions::ConstraintTypes::type_x;
const unsigned int face2_type =
(direction == 0) ?
dealii::internal::MatrixFreeFunctions::ConstraintTypes::type_z :
- (direction == 1) ?
+ (direction == 1) ?
dealii::internal::MatrixFreeFunctions::ConstraintTypes::type_x :
dealii::internal::MatrixFreeFunctions::ConstraintTypes::type_y;
const unsigned int face1 =
(direction == 0) ?
dealii::internal::MatrixFreeFunctions::ConstraintTypes::face_y :
- (direction == 1) ?
+ (direction == 1) ?
dealii::internal::MatrixFreeFunctions::ConstraintTypes::face_z :
dealii::internal::MatrixFreeFunctions::ConstraintTypes::face_x;
const unsigned int face2 =
(direction == 0) ?
dealii::internal::MatrixFreeFunctions::ConstraintTypes::face_z :
- (direction == 1) ?
+ (direction == 1) ?
dealii::internal::MatrixFreeFunctions::ConstraintTypes::face_x :
dealii::internal::MatrixFreeFunctions::ConstraintTypes::face_y;
const unsigned int edge =
(direction == 0) ?
dealii::internal::MatrixFreeFunctions::ConstraintTypes::edge_yz :
- (direction == 1) ?
+ (direction == 1) ?
dealii::internal::MatrixFreeFunctions::ConstraintTypes::edge_zx :
dealii::internal::MatrixFreeFunctions::ConstraintTypes::edge_xy;
const unsigned int constrained_face =
constraint_mask & (face1 | face2 | edge);
- const unsigned int interp_idx =
- (direction == 0) ? x_idx : (direction == 1) ? y_idx : z_idx;
- const unsigned int face1_idx =
- (direction == 0) ? y_idx : (direction == 1) ? z_idx : x_idx;
- const unsigned int face2_idx =
- (direction == 0) ? z_idx : (direction == 1) ? x_idx : y_idx;
+ const unsigned int interp_idx = (direction == 0) ? x_idx :
+ (direction == 1) ? y_idx :
+ z_idx;
+ const unsigned int face1_idx = (direction == 0) ? y_idx :
+ (direction == 1) ? z_idx :
+ x_idx;
+ const unsigned int face2_idx = (direction == 0) ? z_idx :
+ (direction == 1) ? x_idx :
+ y_idx;
Number t = 0;
const bool on_face1 = (constraint_mask & face1_type) ?
{
const unsigned int real_idx =
(direction == 0) ? index3<fe_degree + 1>(i, y_idx, z_idx) :
- (direction == 1) ?
- index3<fe_degree + 1>(x_idx, i, z_idx) :
+ (direction == 1) ? index3<fe_degree + 1>(x_idx, i, z_idx) :
index3<fe_degree + 1>(x_idx, y_idx, i);
const Number w =
{
const unsigned int real_idx =
(direction == 0) ? index3<fe_degree + 1>(i, y_idx, z_idx) :
- (direction == 1) ?
- index3<fe_degree + 1>(x_idx, i, z_idx) :
+ (direction == 1) ? index3<fe_degree + 1>(x_idx, i, z_idx) :
index3<fe_degree + 1>(x_idx, y_idx, i);
const Number w =
template <typename Number, typename VectorizedArrayType>
bool
- FPArrayComparator<Number, VectorizedArrayType>::
- operator()(const std::vector<Number> &v1,
- const std::vector<Number> &v2) const
+ FPArrayComparator<Number, VectorizedArrayType>::operator()(
+ const std::vector<Number> &v1,
+ const std::vector<Number> &v2) const
{
const unsigned int s1 = v1.size(), s2 = v2.size();
if (s1 < s2)
template <typename Number, typename VectorizedArrayType>
bool
- FPArrayComparator<Number, VectorizedArrayType>::
- operator()(const Tensor<1, VectorizedArrayType::size(), Number> &t1,
- const Tensor<1, VectorizedArrayType::size(), Number> &t2) const
+ FPArrayComparator<Number, VectorizedArrayType>::operator()(
+ const Tensor<1, VectorizedArrayType::size(), Number> &t1,
+ const Tensor<1, VectorizedArrayType::size(), Number> &t2) const
{
for (unsigned int k = 0; k < VectorizedArrayType::size(); ++k)
if (t1[k] < t2[k] - tolerance)
template <typename Number, typename VectorizedArrayType>
template <int dim>
bool
- FPArrayComparator<Number, VectorizedArrayType>::
- operator()(const std::array<Tensor<2, dim, Number>, dim + 1> &t1,
- const std::array<Tensor<2, dim, Number>, dim + 1> &t2) const
+ FPArrayComparator<Number, VectorizedArrayType>::operator()(
+ const std::array<Tensor<2, dim, Number>, dim + 1> &t1,
+ const std::array<Tensor<2, dim, Number>, dim + 1> &t2) const
{
for (unsigned int i = 0; i < t1.size(); ++i)
for (unsigned int d = 0; d < dim; ++d)
*/
template <typename DoFHandlerType>
DEAL_II_DEPRECATED const DoFHandlerType &
- get_dof_handler(const unsigned int dof_handler_index = 0) const;
+ get_dof_handler(const unsigned int dof_handler_index = 0) const;
/**
* Return the cell iterator in deal.II speak to a given cell batch
bool lex_faces = false>
void
apply_face(const Number *DEAL_II_RESTRICT in,
- Number *DEAL_II_RESTRICT out) const;
+ Number *DEAL_II_RESTRICT out) const;
const Number2 *shape_values;
const Number2 *shape_gradients;
n_columns,
Number,
Number2>::apply(const Number2 *DEAL_II_RESTRICT
- shape_data,
- const Number * in,
- Number * out)
+ shape_data,
+ const Number *in,
+ Number * out)
{
static_assert(one_line == false || direction == dim - 1,
"Single-line evaluation only works for direction=dim-1.");
Number,
Number2>::apply_face(const Number *DEAL_II_RESTRICT in,
Number *DEAL_II_RESTRICT
- out) const
+ out) const
{
Assert(dim > 0 && (lex_faces || dim < 4),
ExcMessage("Only dim=1,2,3 supported"));
bool lex_faces = false>
void
apply_face(const Number *DEAL_II_RESTRICT in,
- Number *DEAL_II_RESTRICT out) const;
+ Number *DEAL_II_RESTRICT out) const;
const Number2 * shape_values;
const Number2 * shape_gradients;
inline void
EvaluatorTensorProduct<evaluate_general, dim, 0, 0, Number, Number2>::
apply_face(const Number *DEAL_II_RESTRICT in,
- Number *DEAL_II_RESTRICT out) const
+ Number *DEAL_II_RESTRICT out) const
{
static_assert(lex_faces == false, "Not implemented yet.");
const unsigned int first_selected_component)
{
std::unique_ptr<AffineConstraints<typename MatrixType::value_type>>
- constraints_for_matrix;
+ constraints_for_matrix;
const AffineConstraints<typename MatrixType::value_type> &constraints =
internal::create_new_affine_constraints_if_needed(matrix,
constraints_in,
n_components,
Number,
VectorizedArrayType,
- MatrixType>(matrix_free,
- constraints,
- matrix,
- [&](auto &feeval) {
- (owning_class->*cell_operation)(feeval);
- },
- dof_no,
- quad_no,
- first_selected_component);
+ MatrixType>(
+ matrix_free,
+ constraints,
+ matrix,
+ [&](auto &feeval) { (owning_class->*cell_operation)(feeval); },
+ dof_no,
+ quad_no,
+ first_selected_component);
}
#endif // DOXYGEN
*
* @ref AssembleFlags
*/
- inline AssembleFlags operator&(AssembleFlags f1, AssembleFlags f2)
+ inline AssembleFlags
+ operator&(AssembleFlags f1, AssembleFlags f2)
{
return static_cast<AssembleFlags>(static_cast<unsigned int>(f1) &
static_cast<unsigned int>(f2));
copy_data);
};
- mesh_loop(begin,
- end,
- f_cell_worker,
- [&main_class, copier](const CopyData ©_data) {
- (main_class.*copier)(copy_data);
- },
- sample_scratch_data,
- sample_copy_data,
- flags,
- f_boundary_worker,
- f_face_worker,
- queue_length,
- chunk_size);
+ mesh_loop(
+ begin,
+ end,
+ f_cell_worker,
+ [&main_class, copier](const CopyData ©_data) {
+ (main_class.*copier)(copy_data);
+ },
+ sample_scratch_data,
+ sample_copy_data,
+ flags,
+ f_boundary_worker,
+ f_face_worker,
+ queue_length,
+ chunk_size);
}
/**
class MatrixType,
class PreconditionerType>
void
-MGCoarseGridIterativeSolver<VectorType,
- SolverType,
- MatrixType,
- PreconditionerType>::
-operator()(const unsigned int /*level*/,
- VectorType & dst,
- const VectorType &src) const
+ MGCoarseGridIterativeSolver<
+ VectorType,
+ SolverType,
+ MatrixType,
+ PreconditionerType>::operator()(const unsigned int /*level*/,
+ VectorType & dst,
+ const VectorType &src) const
{
Assert(solver != nullptr, ExcNotInitialized());
Assert(matrix != nullptr, ExcNotInitialized());
template <typename number, class VectorType>
void
-MGCoarseGridHouseholder<number, VectorType>::
-operator()(const unsigned int /*level*/,
- VectorType & dst,
- const VectorType &src) const
+MGCoarseGridHouseholder<number, VectorType>::operator()(
+ const unsigned int /*level*/,
+ VectorType & dst,
+ const VectorType &src) const
{
householder.least_squares(dst, src);
}
const unsigned int max_level = (level_relevant_dofs.max_level() == 0) ?
nlevels - 1 :
level_relevant_dofs.max_level();
- const bool user_level_dofs =
+ const bool user_level_dofs =
(level_relevant_dofs.max_level() == 0) ? false : true;
// At this point level_constraint and refinement_edge_indices are empty.
/**
* Access matrix on a level.
*/
- const LinearOperator<VectorType> &operator[](unsigned int level) const;
+ const LinearOperator<VectorType> &
+ operator[](unsigned int level) const;
virtual void
vmult(const unsigned int level,
template <typename VectorType>
- inline const LinearOperator<VectorType> &Matrix<VectorType>::
- operator[](unsigned int level) const
+ inline const LinearOperator<VectorType> &
+ Matrix<VectorType>::operator[](unsigned int level) const
{
return matrices[level];
}
* counting from the last added element.
* `index==0` therefore corresponds to the newset element.
*/
- T &operator[](const std::size_t index);
+ T &
+ operator[](const std::size_t index);
/**
* Read access to an element with index @p index,
* counting from the last added element.
* `index==0` therefore corresponds to the newset element.
*/
- const T &operator[](const std::size_t index) const;
+ const T &
+ operator[](const std::size_t index) const;
/**
* Return the current size of the history.
template <typename T>
-T &FiniteSizeHistory<T>::operator[](const std::size_t ind)
+T &
+FiniteSizeHistory<T>::operator[](const std::size_t ind)
{
AssertIndexRange(ind, data.size());
return *data[ind];
template <typename T>
-const T &FiniteSizeHistory<T>::operator[](const std::size_t ind) const
+const T &
+FiniteSizeHistory<T>::operator[](const std::size_t ind) const
{
AssertIndexRange(ind, data.size());
return *data[ind];
hp::QCollection<dim> q_collection(q);
hp::MappingCollection<dim, spacedim> mapping_collection(mapping);
MatrixCreator::internal::AssemblerData::Scratch<dim, spacedim, number>
- assembler_data(fe_collection,
+ assembler_data(fe_collection,
update_values | update_JxW_values |
update_quadrature_points,
coefficient,
ExcDimensionMismatch(matrix.n(), dof.n_dofs()));
MatrixCreator::internal::AssemblerData::Scratch<dim, spacedim, number>
- assembler_data(dof.get_fe_collection(),
+ assembler_data(dof.get_fe_collection(),
update_values | update_JxW_values |
(coefficient != nullptr ? update_quadrature_points :
UpdateFlags(0)),
ExcDimensionMismatch(matrix.n(), dof.n_dofs()));
MatrixCreator::internal::AssemblerData::Scratch<dim, spacedim, number>
- assembler_data(dof.get_fe_collection(),
+ assembler_data(dof.get_fe_collection(),
update_values | update_JxW_values |
update_quadrature_points,
coefficient,
hp::QCollection<dim> q_collection(q);
hp::MappingCollection<dim, spacedim> mapping_collection(mapping);
MatrixCreator::internal::AssemblerData::Scratch<dim, spacedim, double>
- assembler_data(fe_collection,
+ assembler_data(fe_collection,
update_gradients | update_JxW_values |
(coefficient != nullptr ? update_quadrature_points :
UpdateFlags(0)),
hp::QCollection<dim> q_collection(q);
hp::MappingCollection<dim, spacedim> mapping_collection(mapping);
MatrixCreator::internal::AssemblerData::Scratch<dim, spacedim, double>
- assembler_data(fe_collection,
+ assembler_data(fe_collection,
update_gradients | update_values | update_JxW_values |
update_quadrature_points,
coefficient,
ExcDimensionMismatch(matrix.n(), dof.n_dofs()));
MatrixCreator::internal::AssemblerData::Scratch<dim, spacedim, double>
- assembler_data(dof.get_fe_collection(),
+ assembler_data(dof.get_fe_collection(),
update_gradients | update_JxW_values |
(coefficient != nullptr ? update_quadrature_points :
UpdateFlags(0)),
ExcDimensionMismatch(matrix.n(), dof.n_dofs()));
MatrixCreator::internal::AssemblerData::Scratch<dim, spacedim, double>
- assembler_data(dof.get_fe_collection(),
+ assembler_data(dof.get_fe_collection(),
update_gradients | update_values | update_JxW_values |
update_quadrature_points,
coefficient,
typename Box,
typename Allocators>
void
-ExtractLevelVisitor<Value, Options, Translator, Box, Allocators>::
-operator()(const ExtractLevelVisitor::InternalNode &node)
+ExtractLevelVisitor<Value, Options, Translator, Box, Allocators>::operator()(
+ const ExtractLevelVisitor::InternalNode &node)
{
using ElmentsType =
typename boost::geometry::index::detail::rtree::elements_type<
typename Box,
typename Allocators>
void
-ExtractLevelVisitor<Value, Options, Translator, Box, Allocators>::
-operator()(const ExtractLevelVisitor::Leaf &)
+ExtractLevelVisitor<Value, Options, Translator, Box, Allocators>::operator()(
+ const ExtractLevelVisitor::Leaf &)
{}
template <int dim,
int spacedim,
typename number,
- template <int, int> class M_or_MC>
+ template <int, int>
+ class M_or_MC>
static inline void
do_interpolate_boundary_values(
const M_or_MC<dim, spacedim> & mapping,
template <int dim,
int spacedim,
- template <int, int> class M_or_MC,
- template <int> class Q_or_QC,
+ template <int, int>
+ class M_or_MC,
+ template <int>
+ class Q_or_QC,
typename number>
void
do_project_boundary_values(
const unsigned int lines_per_face =
GeometryInfo<dim>::lines_per_face;
std::vector<std::vector<unsigned int>>
- associated_edge_dof_to_face_dof(lines_per_face,
- std::vector<unsigned int>(degree +
- 1));
+ associated_edge_dof_to_face_dof(
+ lines_per_face, std::vector<unsigned int>(degree + 1));
std::vector<unsigned int> associated_edge_dofs(lines_per_face);
for (unsigned int line = 0; line < lines_per_face; ++line)
const FiniteElement<2> & fe = cell->get_fe();
const std::vector<Tensor<1, 2>> &normals = fe_values.get_normal_vectors();
const unsigned int
- face_coordinate_direction[GeometryInfo<2>::faces_per_cell] = {1,
+ face_coordinate_direction[GeometryInfo<2>::faces_per_cell] = {1,
1,
0,
0};
// Create a small lambda capture wrapping function and call the
// internal implementation
- const auto function_map = [&function](
- const typename DoFHandler<dim, spacedim>::active_cell_iterator &)
- -> const Function<spacedim, typename VectorType::value_type> *
- {
+ const auto function_map =
+ [&function](
+ const typename DoFHandler<dim, spacedim>::active_cell_iterator &)
+ -> const Function<spacedim, typename VectorType::value_type> * {
return &function;
};
{
// Create a small lambda capture wrapping the function map and call the
// internal implementation
- const auto function_map = [&functions](
- const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell)
- -> const Function<spacedim, typename VectorType::value_type> *
- {
+ const auto function_map =
+ [&functions](
+ const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell)
+ -> const Function<spacedim, typename VectorType::value_type> * {
const auto function = functions.find(cell->material_id());
if (function != functions.end())
return function->second;
VectorType & vec,
const bool enforce_zero_boundary = false,
const Quadrature<dim - 1> &q_boundary = (dim > 1 ?
- QGauss<dim - 1>(2) :
- Quadrature<dim - 1>(0)),
+ QGauss<dim - 1>(2) :
+ Quadrature<dim - 1>(0)),
const bool project_to_boundary_first = false);
/**
VectorType & vec,
const bool enforce_zero_boundary = false,
const Quadrature<dim - 1> &q_boundary = (dim > 1 ?
- QGauss<dim - 1>(2) :
- Quadrature<dim - 1>(0)),
+ QGauss<dim - 1>(2) :
+ Quadrature<dim - 1>(0)),
const bool project_to_boundary_first = false);
/**
*/
template <int dim,
int spacedim,
- template <int, int> class M_or_MC,
- template <int> class Q_or_QC,
+ template <int, int>
+ class M_or_MC,
+ template <int>
+ class Q_or_QC,
typename number>
void
project_compute_b_v(
template <int dim,
int spacedim,
typename VectorType,
- template <int, int> class M_or_MC,
- template <int> class Q_or_QC>
+ template <int, int>
+ class M_or_MC,
+ template <int>
+ class Q_or_QC>
void
do_project(
const M_or_MC<dim, spacedim> & mapping,
template <int dim, int spacedim>
inline bool
- ParticleAccessor<dim, spacedim>::
- operator!=(const ParticleAccessor<dim, spacedim> &other) const
+ ParticleAccessor<dim, spacedim>::operator!=(
+ const ParticleAccessor<dim, spacedim> &other) const
{
return !(*this == other);
}
template <int dim, int spacedim>
inline bool
- ParticleAccessor<dim, spacedim>::
- operator==(const ParticleAccessor<dim, spacedim> &other) const
+ ParticleAccessor<dim, spacedim>::operator==(
+ const ParticleAccessor<dim, spacedim> &other) const
{
return (property_pool == other.property_pool) && (cell == other.cell) &&
(particle_index_within_cell == other.particle_index_within_cell);
* @deprecated Use locally_owned_particle_ids() instead.
*/
DEAL_II_DEPRECATED IndexSet
- locally_relevant_ids() const;
+ locally_relevant_ids() const;
/**
* Extract an IndexSet with global dimensions equal to
for (auto &p : *this)
{
auto new_point(displace_particles ? p.get_location() :
- Point<spacedim>());
+ Point<spacedim>());
const auto id = p.get_id();
for (unsigned int i = 0; i < spacedim; ++i)
new_point[i] += input_vector[id * spacedim + i];
* Dereferencing operator, returns a reference to an accessor. Usage is thus
* like <tt>(*i).get_id ();</tt>
*/
- const ParticleAccessor<dim, spacedim> &operator*() const;
+ const ParticleAccessor<dim, spacedim> &
+ operator*() const;
/**
* Dereferencing operator, non-@p const version.
*/
- ParticleAccessor<dim, spacedim> &operator*();
+ ParticleAccessor<dim, spacedim> &
+ operator*();
/**
* Dereferencing operator, returns a pointer of the particle pointed to.
*
* There is a @p const and a non-@p const version.
*/
- const ParticleAccessor<dim, spacedim> *operator->() const;
+ const ParticleAccessor<dim, spacedim> *
+ operator->() const;
/**
* Dereferencing operator, non-@p const version.
*/
- ParticleAccessor<dim, spacedim> *operator->();
+ ParticleAccessor<dim, spacedim> *
+ operator->();
/**
* Compare for equality.
template <int dim, int spacedim>
- inline ParticleAccessor<dim, spacedim> &ParticleIterator<dim, spacedim>::
- operator*()
+ inline ParticleAccessor<dim, spacedim> &
+ ParticleIterator<dim, spacedim>::operator*()
{
return accessor;
}
template <int dim, int spacedim>
- inline ParticleAccessor<dim, spacedim> *ParticleIterator<dim, spacedim>::
- operator->()
+ inline ParticleAccessor<dim, spacedim> *
+ ParticleIterator<dim, spacedim>::operator->()
{
return &(this->operator*());
}
template <int dim, int spacedim>
inline const ParticleAccessor<dim, spacedim> &
- ParticleIterator<dim, spacedim>::operator*() const
+ ParticleIterator<dim, spacedim>::operator*() const
{
return accessor;
}
template <int dim, int spacedim>
inline const ParticleAccessor<dim, spacedim> *
- ParticleIterator<dim, spacedim>::operator->() const
+ ParticleIterator<dim, spacedim>::operator->() const
{
return &(this->operator*());
}
template <int dim, int spacedim>
inline bool
- ParticleIterator<dim, spacedim>::
- operator!=(const ParticleIterator<dim, spacedim> &other) const
+ ParticleIterator<dim, spacedim>::operator!=(
+ const ParticleIterator<dim, spacedim> &other) const
{
return accessor != other.accessor;
}
template <int dim, int spacedim>
inline bool
- ParticleIterator<dim, spacedim>::
- operator==(const ParticleIterator<dim, spacedim> &other) const
+ ParticleIterator<dim, spacedim>::operator==(
+ const ParticleIterator<dim, spacedim> &other) const
{
return accessor == other.accessor;
}
/**
* Access the N_Vector that is viewed by this object.
*/
- N_Vector operator->() const;
+ N_Vector
+ operator->() const;
private:
/**
template <typename VectorType>
-N_Vector SUNDIALS::internal::NVectorView<VectorType>::operator->() const
+N_Vector
+SUNDIALS::internal::NVectorView<VectorType>::operator->() const
{
Assert(vector_ptr != nullptr, ExcNotInitialized());
return vector_ptr.get();
template <int spacedim>
- void Patch<0, spacedim>::swap(Patch<0, spacedim> &other_patch)
+ void
+ Patch<0, spacedim>::swap(Patch<0, spacedim> &other_patch)
{
std::swap(vertices, other_patch.vertices);
std::swap(patch_index, other_patch.patch_index);
* camera_horizontal, necessary for the correct alignment of the
* later images), and the focus of the camera (float camera_focus).
*/
- Point<2> svg_project_point(Point<3> point,
- Point<3> camera_position,
- Point<3> camera_direction,
- Point<3> camera_horizontal,
- float camera_focus)
+ Point<2>
+ svg_project_point(Point<3> point,
+ Point<3> camera_position,
+ Point<3> camera_direction,
+ Point<3> camera_horizontal,
+ float camera_focus)
{
Point<3> camera_vertical;
camera_vertical[0] = camera_horizontal[1] * camera_direction[2] -
* Function to compute the gradient parameters for a triangle with given
* values for the vertices.
*/
- Point<6> svg_get_gradient_parameters(Point<3> points[])
+ Point<6>
+ svg_get_gradient_parameters(Point<3> points[])
{
Point<3> v_min, v_max, v_inter;
{
const double d = this->center.distance(points[i]);
values[i] = ((d < this->radius) ?
- (this->radius - d) / this->radius * this->rescaling :
- 0.);
+ (this->radius - d) / this->radius * this->rescaling :
+ 0.);
}
else
std::fill(values.begin(), values.end(), 0.);
* calculates out[i][j] += v*(in1[i]*in2[j]+in1[j]*in2[i])
*/
template <int dim>
- void add_outer_product(SymmetricTensor<2, dim> &out,
- const double val,
- const Tensor<1, dim> & in1,
- const Tensor<1, dim> & in2)
+ void
+ add_outer_product(SymmetricTensor<2, dim> &out,
+ const double val,
+ const Tensor<1, dim> & in1,
+ const Tensor<1, dim> & in2)
{
if (val != 0.)
for (unsigned int i = 0; i < dim; i++)
* calculates out[i][j] += v*in[i]in[j]
*/
template <int dim>
- void add_outer_product(SymmetricTensor<2, dim> &out,
- const double val,
- const Tensor<1, dim> & in)
+ void
+ add_outer_product(SymmetricTensor<2, dim> &out,
+ const double val,
+ const Tensor<1, dim> & in)
{
if (val != 0.)
for (unsigned int i = 0; i < dim; i++)
#ifndef DOXYGEN
-IndexSet IndexSet::operator&(const IndexSet &is) const
+IndexSet
+IndexSet::operator&(const IndexSet &is) const
{
Assert(size() == is.size(), ExcDimensionMismatch(size(), is.size()));
dim == 2 ?
QAnisotropic<dim>(QTelles<1>(base_quad, Point<1>(singularity[0])),
QTelles<1>(base_quad, Point<1>(singularity[1]))) :
- dim == 3 ?
+ dim == 3 ?
QAnisotropic<dim>(QTelles<1>(base_quad, Point<1>(singularity[0])),
QTelles<1>(base_quad, Point<1>(singularity[1])),
QTelles<1>(base_quad, Point<1>(singularity[2]))) :
namespace
{
template <int dim, typename Number>
- void calculate_svd_in_place(Tensor<2, dim, Number> &A_in_VT_out,
- Tensor<2, dim, Number> &U)
+ void
+ calculate_svd_in_place(Tensor<2, dim, Number> &A_in_VT_out,
+ Tensor<2, dim, Number> &U)
{
// inputs: A
// outputs: V^T, U
#endif
if (dim == 0)
- {
- }
+ {}
else if (dim == 1)
internal::compute_tensor_index(i,
polynomials[0].size(),
namespace internal
{
[[noreturn]] void
- handle_std_exception(const std::exception &exc) {
+ handle_std_exception(const std::exception &exc)
+ {
// lock the following context
// to ensure that we don't
// print things over each other
- [[noreturn]] void handle_unknown_exception()
+ [[noreturn]] void
+ handle_unknown_exception()
{
// lock the following context
// to ensure that we don't
}
- Expression operator!(const Expression &expression)
+ Expression
+ operator!(const Expression &expression)
{
Assert(SE::is_a_Boolean(expression.get_value()),
ExcMessage("The expression must return a boolean type."));
}
- Expression operator&(const Expression &lhs, const Expression &rhs)
+ Expression
+ operator&(const Expression &lhs, const Expression &rhs)
{
Assert(SE::is_a_Boolean(lhs.get_value()),
ExcMessage("The lhs expression must return a boolean type."));
}
- Expression operator*(Expression lhs, const Expression &rhs)
+ Expression
+ operator*(Expression lhs, const Expression &rhs)
{
lhs *= rhs;
return lhs;
\{
namespace GridRefinement
\{
- template void refine_and_coarsen_fixed_number<deal_II_dimension - 1,
- S,
- deal_II_dimension>(
+ template void
+ refine_and_coarsen_fixed_number<deal_II_dimension - 1,
+ S,
+ deal_II_dimension>(
parallel::distributed::Triangulation<deal_II_dimension - 1,
deal_II_dimension> &,
const dealii::Vector<S> &,
const double,
const types::global_cell_index);
- template void refine_and_coarsen_fixed_fraction<deal_II_dimension - 1,
- S,
- deal_II_dimension>(
+ template void
+ refine_and_coarsen_fixed_fraction<deal_II_dimension - 1,
+ S,
+ deal_II_dimension>(
parallel::distributed::Triangulation<deal_II_dimension - 1,
deal_II_dimension> &,
const dealii::Vector<S> &,
template <>
- bool quadrant_is_ancestor<1>(types<1>::quadrant const &q1,
- types<1>::quadrant const &q2)
+ bool
+ quadrant_is_ancestor<1>(types<1>::quadrant const &q1,
+ types<1>::quadrant const &q2)
{
// determine level of quadrants
const int level_1 = (q1 << types<1>::max_n_child_indices_bits) >>
template <>
- void init_coarse_quadrant<1>(typename types<1>::quadrant &quad)
+ void
+ init_coarse_quadrant<1>(typename types<1>::quadrant &quad)
{
quad = 0;
}
# ifndef DOXYGEN
template <>
- void
- Triangulation<2, 2>::copy_new_triangulation_to_p4est(
+ void Triangulation<2, 2>::copy_new_triangulation_to_p4est(
std::integral_constant<int, 2>)
{
const unsigned int dim = 2, spacedim = 2;
// TODO: This is a verbatim copy of the 2,2 case. However, we can't just
// specialize the dim template argument, but let spacedim open
template <>
- void
- Triangulation<2, 3>::copy_new_triangulation_to_p4est(
+ void Triangulation<2, 3>::copy_new_triangulation_to_p4est(
std::integral_constant<int, 2>)
{
const unsigned int dim = 2, spacedim = 3;
template <>
- void
- Triangulation<3, 3>::copy_new_triangulation_to_p4est(
+ void Triangulation<3, 3>::copy_new_triangulation_to_p4est(
std::integral_constant<int, 3>)
{
const int dim = 3, spacedim = 3;
// comes out of this cell.
typename dealii::internal::p4est::types<dim>::quadrant
- p4est_coarse_cell;
+ p4est_coarse_cell;
typename dealii::internal::p4est::types<dim>::tree *tree =
init_tree(cell->index());
const unsigned int second_dealii_idx_on_face =
lower_idx == 0 ? left_to_right[face_pair.orientation.to_ulong()]
[first_dealii_idx_on_face] :
- right_to_left[face_pair.orientation.to_ulong()]
+ right_to_left[face_pair.orientation.to_ulong()]
[first_dealii_idx_on_face];
const unsigned int second_dealii_idx_on_cell =
GeometryInfo<dim>::face_to_cell_vertices(
}
template <int spacedim>
- static void reserve_space_mg(DoFHandler<1, spacedim> &dof_handler)
+ static void
+ reserve_space_mg(DoFHandler<1, spacedim> &dof_handler)
{
Assert(dof_handler.get_triangulation().n_levels() > 0,
ExcMessage("Invalid triangulation"));
}
template <int spacedim>
- static void reserve_space_mg(DoFHandler<2, spacedim> &dof_handler)
+ static void
+ reserve_space_mg(DoFHandler<2, spacedim> &dof_handler)
{
Assert(dof_handler.get_triangulation().n_levels() > 0,
ExcMessage("Invalid triangulation"));
}
template <int spacedim>
- static void reserve_space_mg(DoFHandler<3, spacedim> &dof_handler)
+ static void
+ reserve_space_mg(DoFHandler<3, spacedim> &dof_handler)
{
Assert(dof_handler.get_triangulation().n_levels() > 0,
ExcMessage("Invalid triangulation"));
* selected when calling @p distribute_dofs the last time.
*/
template <int spacedim>
- static void reserve_space(dealii::DoFHandler<1, spacedim> &dof_handler)
+ static void
+ reserve_space(dealii::DoFHandler<1, spacedim> &dof_handler)
{
Assert(dof_handler.fe_collection.size() > 0,
(typename dealii::DoFHandler<1, spacedim>::ExcNoFESelected()));
template <int spacedim>
- static void reserve_space(dealii::DoFHandler<2, spacedim> &dof_handler)
+ static void
+ reserve_space(dealii::DoFHandler<2, spacedim> &dof_handler)
{
Assert(dof_handler.fe_collection.size() > 0,
(typename dealii::DoFHandler<1, spacedim>::ExcNoFESelected()));
template <int spacedim>
- static void reserve_space(dealii::DoFHandler<3, spacedim> &dof_handler)
+ static void
+ reserve_space(dealii::DoFHandler<3, spacedim> &dof_handler)
{
Assert(dof_handler.fe_collection.size() > 0,
(typename dealii::DoFHandler<1, spacedim>::ExcNoFESelected()));
* by a dominating valid one.
*/
template <int spacedim>
- static void merge_invalid_line_dofs_on_ghost_interfaces(
+ static void
+ merge_invalid_line_dofs_on_ghost_interfaces(
DoFHandler<1, spacedim> &dof_handler)
{
(void)dof_handler;
template <int spacedim>
- static void merge_invalid_quad_dofs_on_ghost_interfaces(
+ static void
+ merge_invalid_quad_dofs_on_ghost_interfaces(
DoFHandler<3, spacedim> &dof_handler)
{
Assert(dof_handler.hp_capability_enabled == true,
my_new_indices.size());
{
std::set<types::global_dof_index>::const_iterator
- next_erased_index = erase_these_indices.begin();
+ next_erased_index = erase_these_indices.begin();
types::global_dof_index next_new_index = 0;
for (unsigned int i = 0; i < translate_indices.size(); ++i)
if ((next_erased_index != erase_these_indices.end()) &&
template <int dim, int spacedim>
bool
-FiniteElement<dim, spacedim>::
-operator==(const FiniteElement<dim, spacedim> &f) const
+FiniteElement<dim, spacedim>::operator==(
+ const FiniteElement<dim, spacedim> &f) const
{
// Compare fields in roughly increasing order of how expensive the
// comparison is
template <int dim, int spacedim>
bool
-FiniteElement<dim, spacedim>::
-operator!=(const FiniteElement<dim, spacedim> &f) const
+FiniteElement<dim, spacedim>::operator!=(
+ const FiniteElement<dim, spacedim> &f) const
{
return !(*this == f);
}
system_matrix_inv.invert(system_matrix);
const unsigned int
- line_coordinate[GeometryInfo<2>::lines_per_cell] = {1, 1, 0, 0};
+ line_coordinate[GeometryInfo<2>::lines_per_cell] = {1, 1, 0, 0};
Vector<double> system_rhs(system_matrix.m());
Vector<double> solution(system_rhs.size());
namespace
{
- void set_k_vectors(Table<1, Tensor<1, 1>> &k_vectors, const unsigned int N)
+ void
+ set_k_vectors(Table<1, Tensor<1, 1>> &k_vectors, const unsigned int N)
{
k_vectors.reinit(TableIndices<1>(N));
for (unsigned int i = 0; i < N; ++i)
k_vectors(i)[0] = 2. * numbers::PI * i;
}
- void set_k_vectors(Table<2, Tensor<1, 2>> &k_vectors, const unsigned int N)
+ void
+ set_k_vectors(Table<2, Tensor<1, 2>> &k_vectors, const unsigned int N)
{
k_vectors.reinit(TableIndices<2>(N, N));
for (unsigned int i = 0; i < N; ++i)
}
}
- void set_k_vectors(Table<3, Tensor<1, 3>> &k_vectors, const unsigned int N)
+ void
+ set_k_vectors(Table<3, Tensor<1, 3>> &k_vectors, const unsigned int N)
{
k_vectors.reinit(TableIndices<3>(N, N, N));
for (unsigned int i = 0; i < N; ++i)
template <int dim, int spacedim>
inline bool
- Fourier<dim, spacedim>::
- operator==(const Fourier<dim, spacedim> &fourier) const
+ Fourier<dim, spacedim>::operator==(
+ const Fourier<dim, spacedim> &fourier) const
{
return (
(n_coefficients_per_direction == fourier.n_coefficients_per_direction) &&
template <int dim, int spacedim>
inline bool
- Legendre<dim, spacedim>::
- operator==(const Legendre<dim, spacedim> &legendre) const
+ Legendre<dim, spacedim>::operator==(
+ const Legendre<dim, spacedim> &legendre) const
{
return (
(n_coefficients_per_direction == legendre.n_coefficients_per_direction) &&
const hp::QCollection<dim - 1> *face_quadrature = nullptr;
const Quadrature<dim - 1> * sub_face_quadrature = nullptr;
const unsigned int n_q_points = quadrature.size() == 1 ?
- quadrature[0].size() :
- quadrature[face_no].size();
+ quadrature[0].size() :
+ quadrature[face_no].size();
// static cast to the common base class of quadrature being either
// Quadrature<dim> or Quadrature<dim-1>:
template <int dim, int spacedim>
template <typename CI>
-FEValuesBase<dim, spacedim>::CellIterator<CI>::
-operator typename Triangulation<dim, spacedim>::cell_iterator() const
+FEValuesBase<dim, spacedim>::CellIterator<
+ CI>::operator typename Triangulation<dim, spacedim>::cell_iterator() const
{
return cell;
}
{
AssertDimension(transformation_function.n_components, spacedim);
- this->initialize(mapping,
- tria,
- [&](const auto &, const auto &point) {
- Point<spacedim> new_point;
- for (int c = 0; c < spacedim; ++c)
- new_point[c] = transformation_function.value(point, c);
- return new_point;
- },
- function_describes_relative_displacement);
+ this->initialize(
+ mapping,
+ tria,
+ [&](const auto &, const auto &point) {
+ Point<spacedim> new_point;
+ for (int c = 0; c < spacedim; ++c)
+ new_point[c] = transformation_function.value(point, c);
+ return new_point;
+ },
+ function_describes_relative_displacement);
uses_level_info = true;
}
/**
* Create a serial/parallel distributed triangulation.
*/
- void create_triangulation(
+ void
+ create_triangulation(
Triangulation<2> & tria_grid,
std::vector<GridTools::PeriodicFacePair<
typename Triangulation<2>::cell_iterator>> *periodic_faces) const
/**
* Specialization for parallel fully-distributed triangulations.
*/
- void create_triangulation(
+ void
+ create_triangulation(
parallel::fullydistributed::Triangulation<2> ¶llel_grid,
std::vector<GridTools::PeriodicFacePair<
typename Triangulation<2>::cell_iterator>> *periodic_faces) const
* Create 6 coarse grids based on points A-L (class fields) and merges
* them to one triangulation.
*/
- void make_coarse_grid(Triangulation<2> &tria) const
+ void
+ make_coarse_grid(Triangulation<2> &tria) const
{
// create vector of serial triangulations for each block and
// temporary storage for merging them
* - 4: upper far-field side
* - 5: lower far-field side
*/
- static void set_boundary_ids(Triangulation<2> &tria)
+ static void
+ set_boundary_ids(Triangulation<2> &tria)
{
for (auto cell : tria.active_cell_iterators())
for (unsigned int f : GeometryInfo<2>::face_indices())
* dense mesh next to airfoil geometry and receive an inclined boundary
* between block 2&3 and 5&6, respectively
*/
- void interpolate(Triangulation<2> &tria) const
+ void
+ interpolate(Triangulation<2> &tria) const
{
// array storing the information if a vertex was processed
std::vector<bool> vertex_processed(tria.n_vertices(), false);
- void internal_create_triangulation(
+ void
+ internal_create_triangulation(
Triangulation<2, 2> & tria,
std::vector<GridTools::PeriodicFacePair<
typename Triangulation<2, 2>::cell_iterator>> *periodic_faces,
}
template <>
- void create_triangulation(Triangulation<1, 1> &, const AdditionalData &)
+ void
+ create_triangulation(Triangulation<1, 1> &, const AdditionalData &)
{
Assert(false, ExcMessage("Airfoils only exist for 2D and 3D!"));
}
template <>
- void create_triangulation(Triangulation<1, 1> &,
- std::vector<GridTools::PeriodicFacePair<
- typename Triangulation<1, 1>::cell_iterator>> &,
- const AdditionalData &)
+ void
+ create_triangulation(Triangulation<1, 1> &,
+ std::vector<GridTools::PeriodicFacePair<
+ typename Triangulation<1, 1>::cell_iterator>> &,
+ const AdditionalData &)
{
Assert(false, ExcMessage("Airfoils only exist for 2D and 3D!"));
}
template <>
- void create_triangulation(Triangulation<2, 2> & tria,
- const AdditionalData &additional_data)
+ void
+ create_triangulation(Triangulation<2, 2> & tria,
+ const AdditionalData &additional_data)
{
internal_create_triangulation(tria, nullptr, additional_data);
}
template <>
- void create_triangulation(
+ void
+ create_triangulation(
Triangulation<2, 2> & tria,
std::vector<GridTools::PeriodicFacePair<
typename Triangulation<2, 2>::cell_iterator>> &periodic_faces,
template <>
- void create_triangulation(
+ void
+ create_triangulation(
Triangulation<3, 3> & tria,
std::vector<GridTools::PeriodicFacePair<
typename Triangulation<3, 3>::cell_iterator>> &periodic_faces,
template <int spacedim>
- void colorize_subdivided_hyper_rectangle(Triangulation<1, spacedim> &tria,
- const Point<spacedim> &,
- const Point<spacedim> &,
- const double)
+ void
+ colorize_subdivided_hyper_rectangle(Triangulation<1, spacedim> &tria,
+ const Point<spacedim> &,
+ const Point<spacedim> &,
+ const double)
{
for (typename Triangulation<1, spacedim>::cell_iterator cell =
tria.begin();
* Assign boundary number zero to the inner shell boundary and 1 to the
* outer.
*/
- void colorize_hyper_shell(Triangulation<2> &tria,
- const Point<2> &,
- const double,
- const double)
+ void
+ colorize_hyper_shell(Triangulation<2> &tria,
+ const Point<2> &,
+ const double,
+ const double)
{
// In spite of receiving geometrical
// data, we do this only based on
* Assign boundary number zero to the inner shell boundary and 1 to the
* outer.
*/
- void colorize_hyper_shell(Triangulation<3> &tria,
- const Point<3> &,
- const double,
- const double)
+ void
+ colorize_hyper_shell(Triangulation<3> &tria,
+ const Point<3> &,
+ const double,
+ const double)
{
// the following uses a good amount
// of knowledge about the
* shell boundary, two to the face with x=0, three to the face with y=0,
* four to the face with z=0.
*/
- void colorize_quarter_hyper_shell(Triangulation<3> &tria,
- const Point<3> & center,
- const double inner_radius,
- const double outer_radius)
+ void
+ colorize_quarter_hyper_shell(Triangulation<3> &tria,
+ const Point<3> & center,
+ const double inner_radius,
+ const double outer_radius)
{
if (tria.n_cells() != 3)
AssertThrow(false, ExcNotImplemented());
}
}
- void moebius(Triangulation<3> & tria,
- const unsigned int n_cells,
- const unsigned int n_rotations,
- const double R,
- const double r)
+ void
+ moebius(Triangulation<3> & tria,
+ const unsigned int n_cells,
+ const unsigned int n_rotations,
+ const double R,
+ const double r)
{
const unsigned int dim = 3;
Assert(n_cells > 4,
template <>
- void torus<2, 3>(Triangulation<2, 3> &tria,
- const double R,
- const double r,
- const unsigned int,
- const double)
+ void
+ torus<2, 3>(Triangulation<2, 3> &tria,
+ const double R,
+ const double r,
+ const unsigned int,
+ const double)
{
Assert(R > r,
ExcMessage("Outer radius R must be greater than the inner "
template <>
- void torus<3, 3>(Triangulation<3, 3> &tria,
- const double R,
- const double r,
- const unsigned int n_cells_toroidal,
- const double phi)
+ void
+ torus<3, 3>(Triangulation<3, 3> &tria,
+ const double R,
+ const double r,
+ const unsigned int n_cells_toroidal,
+ const double phi)
{
Assert(R > r,
ExcMessage("Outer radius R must be greater than the inner "
template <>
- void parallelogram(Triangulation<3> &,
- const Point<3> (&/*corners*/)[3],
- const bool /*colorize*/)
+ void
+ parallelogram(Triangulation<3> &,
+ const Point<3> (&/*corners*/)[3],
+ const bool /*colorize*/)
{
Assert(false, ExcNotImplemented());
}
template <>
- void parallelogram(Triangulation<1> &,
- const Point<1> (&/*corners*/)[1],
- const bool /*colorize*/)
+ void
+ parallelogram(Triangulation<1> &,
+ const Point<1> (&/*corners*/)[1],
+ const bool /*colorize*/)
{
Assert(false, ExcNotImplemented());
}
// Implementation for 2D only
template <>
- void parallelogram(Triangulation<2> &tria,
- const Point<2> (&corners)[2],
- const bool colorize)
+ void
+ parallelogram(Triangulation<2> &tria,
+ const Point<2> (&corners)[2],
+ const bool colorize)
{
Point<2> origin;
std::array<Tensor<1, 2>, 2> edges;
template <>
void
- subdivided_hyper_rectangle(Triangulation<1> & tria,
- const std::vector<std::vector<double>> &spacing,
- const Point<1> & p,
- const Table<1, types::material_id> &material_id,
- const bool colorize)
+ subdivided_hyper_rectangle(Triangulation<1> & tria,
+ const std::vector<std::vector<double>> &spacing,
+ const Point<1> & p,
+ const Table<1, types::material_id> &material_id,
+ const bool colorize)
{
Assert(spacing.size() == 1, ExcInvalidRepetitionsDimension(1));
template <>
void
- subdivided_hyper_rectangle(Triangulation<2> & tria,
- const std::vector<std::vector<double>> &spacing,
- const Point<2> & p,
- const Table<2, types::material_id> &material_id,
- const bool colorize)
+ subdivided_hyper_rectangle(Triangulation<2> & tria,
+ const std::vector<std::vector<double>> &spacing,
+ const Point<2> & p,
+ const Table<2, types::material_id> &material_id,
+ const bool colorize)
{
Assert(spacing.size() == 2, ExcInvalidRepetitionsDimension(2));
template <>
void
- subdivided_hyper_rectangle(Triangulation<3> & tria,
- const std::vector<std::vector<double>> &spacing,
- const Point<3> & p,
- const Table<3, types::material_id> &material_id,
- const bool colorize)
+ subdivided_hyper_rectangle(Triangulation<3> & tria,
+ const std::vector<std::vector<double>> &spacing,
+ const Point<3> & p,
+ const Table<3, types::material_id> &material_id,
+ const bool colorize)
{
const unsigned int dim = 3;
template <>
- void plate_with_a_hole(Triangulation<1> & /*tria*/,
- const double /*inner_radius*/,
- const double /*outer_radius*/,
- const double /*pad_bottom*/,
- const double /*pad_top*/,
- const double /*pad_left*/,
- const double /*pad_right*/,
- const Point<1> & /*center*/,
- const types::manifold_id /*polar_manifold_id*/,
- const types::manifold_id /*tfi_manifold_id*/,
- const double /*L*/,
- const unsigned int /*n_slices*/,
- const bool /*colorize*/)
+ void
+ plate_with_a_hole(Triangulation<1> & /*tria*/,
+ const double /*inner_radius*/,
+ const double /*outer_radius*/,
+ const double /*pad_bottom*/,
+ const double /*pad_top*/,
+ const double /*pad_left*/,
+ const double /*pad_right*/,
+ const Point<1> & /*center*/,
+ const types::manifold_id /*polar_manifold_id*/,
+ const types::manifold_id /*tfi_manifold_id*/,
+ const double /*L*/,
+ const unsigned int /*n_slices*/,
+ const bool /*colorize*/)
{
Assert(false, ExcNotImplemented());
}
template <>
- void channel_with_cylinder(Triangulation<1> & /*tria*/,
- const double /*shell_region_width*/,
- const unsigned int /*n_shells*/,
- const double /*skewness*/,
- const bool /*colorize*/)
+ void
+ channel_with_cylinder(Triangulation<1> & /*tria*/,
+ const double /*shell_region_width*/,
+ const unsigned int /*n_shells*/,
+ const double /*skewness*/,
+ const bool /*colorize*/)
{
Assert(false, ExcNotImplemented());
}
template <>
- void plate_with_a_hole(Triangulation<2> & tria,
- const double inner_radius,
- const double outer_radius,
- const double pad_bottom,
- const double pad_top,
- const double pad_left,
- const double pad_right,
- const Point<2> & new_center,
- const types::manifold_id polar_manifold_id,
- const types::manifold_id tfi_manifold_id,
- const double L,
- const unsigned int /*n_slices*/,
- const bool colorize)
+ void
+ plate_with_a_hole(Triangulation<2> & tria,
+ const double inner_radius,
+ const double outer_radius,
+ const double pad_bottom,
+ const double pad_top,
+ const double pad_left,
+ const double pad_right,
+ const Point<2> & new_center,
+ const types::manifold_id polar_manifold_id,
+ const types::manifold_id tfi_manifold_id,
+ const double L,
+ const unsigned int /*n_slices*/,
+ const bool colorize)
{
const bool with_padding =
pad_bottom > 0 || pad_top > 0 || pad_left > 0 || pad_right > 0;
template <>
- void plate_with_a_hole(Triangulation<3> & tria,
- const double inner_radius,
- const double outer_radius,
- const double pad_bottom,
- const double pad_top,
- const double pad_left,
- const double pad_right,
- const Point<3> & new_center,
- const types::manifold_id polar_manifold_id,
- const types::manifold_id tfi_manifold_id,
- const double L,
- const unsigned int n_slices,
- const bool colorize)
+ void
+ plate_with_a_hole(Triangulation<3> & tria,
+ const double inner_radius,
+ const double outer_radius,
+ const double pad_bottom,
+ const double pad_top,
+ const double pad_left,
+ const double pad_right,
+ const Point<3> & new_center,
+ const types::manifold_id polar_manifold_id,
+ const types::manifold_id tfi_manifold_id,
+ const double L,
+ const unsigned int n_slices,
+ const bool colorize)
{
Triangulation<2> tria_2;
plate_with_a_hole(tria_2,
template <>
- void channel_with_cylinder(Triangulation<2> & tria,
- const double shell_region_width,
- const unsigned int n_shells,
- const double skewness,
- const bool colorize)
+ void
+ channel_with_cylinder(Triangulation<2> & tria,
+ const double shell_region_width,
+ const unsigned int n_shells,
+ const double skewness,
+ const bool colorize)
{
Assert(0.0 <= shell_region_width && shell_region_width < 0.05,
ExcMessage("The width of the shell region must be less than 0.05 "
template <>
- void channel_with_cylinder(Triangulation<3> & tria,
- const double shell_region_width,
- const unsigned int n_shells,
- const double skewness,
- const bool colorize)
+ void
+ channel_with_cylinder(Triangulation<3> & tria,
+ const double shell_region_width,
+ const unsigned int n_shells,
+ const double skewness,
+ const bool colorize)
{
Triangulation<2> tria_2;
channel_with_cylinder(
template <>
void
- hyper_cube_slit(Triangulation<1> &, const double, const double, const bool)
+ hyper_cube_slit(Triangulation<1> &, const double, const double, const bool)
{
Assert(false, ExcNotImplemented());
}
template <>
- void enclosed_hyper_cube(Triangulation<1> &,
- const double,
- const double,
- const double,
- const bool)
+ void
+ enclosed_hyper_cube(Triangulation<1> &,
+ const double,
+ const double,
+ const double,
+ const bool)
{
Assert(false, ExcNotImplemented());
}
template <>
- void hyper_L(Triangulation<1> &, const double, const double, const bool)
+ void
+ hyper_L(Triangulation<1> &, const double, const double, const bool)
{
Assert(false, ExcNotImplemented());
}
template <>
void
- hyper_ball(Triangulation<1> &, const Point<1> &, const double, const bool)
+ hyper_ball(Triangulation<1> &, const Point<1> &, const double, const bool)
{
Assert(false, ExcNotImplemented());
}
template <>
- void cylinder(Triangulation<1> &, const double, const double)
+ void
+ cylinder(Triangulation<1> &, const double, const double)
{
Assert(false, ExcNotImplemented());
}
template <>
- void subdivided_cylinder(Triangulation<1> &,
- const unsigned int,
- const double,
- const double)
+ void
+ subdivided_cylinder(Triangulation<1> &,
+ const unsigned int,
+ const double,
+ const double)
{
Assert(false, ExcNotImplemented());
}
template <>
void
- truncated_cone(Triangulation<1> &, const double, const double, const double)
+ truncated_cone(Triangulation<1> &, const double, const double, const double)
{
Assert(false, ExcNotImplemented());
}
template <>
- void hyper_shell(Triangulation<1> &,
- const Point<1> &,
- const double,
- const double,
- const unsigned int,
- const bool)
+ void
+ hyper_shell(Triangulation<1> &,
+ const Point<1> &,
+ const double,
+ const double,
+ const unsigned int,
+ const bool)
{
Assert(false, ExcNotImplemented());
}
template <>
- void cylinder_shell(Triangulation<1> &,
- const double,
- const double,
- const double,
- const unsigned int,
- const unsigned int)
+ void
+ cylinder_shell(Triangulation<1> &,
+ const double,
+ const double,
+ const double,
+ const unsigned int,
+ const unsigned int)
{
Assert(false, ExcNotImplemented());
}
template <>
- void quarter_hyper_ball(Triangulation<1> &, const Point<1> &, const double)
+ void
+ quarter_hyper_ball(Triangulation<1> &, const Point<1> &, const double)
{
Assert(false, ExcNotImplemented());
}
template <>
- void half_hyper_ball(Triangulation<1> &, const Point<1> &, const double)
+ void
+ half_hyper_ball(Triangulation<1> &, const Point<1> &, const double)
{
Assert(false, ExcNotImplemented());
}
template <>
- void half_hyper_shell(Triangulation<1> &,
- const Point<1> &,
- const double,
- const double,
- const unsigned int,
- const bool)
+ void
+ half_hyper_shell(Triangulation<1> &,
+ const Point<1> &,
+ const double,
+ const double,
+ const unsigned int,
+ const bool)
{
Assert(false, ExcNotImplemented());
}
template <>
- void quarter_hyper_shell(Triangulation<1> &,
- const Point<1> &,
- const double,
- const double,
- const unsigned int,
- const bool)
+ void
+ quarter_hyper_shell(Triangulation<1> &,
+ const Point<1> &,
+ const double,
+ const double,
+ const unsigned int,
+ const bool)
{
Assert(false, ExcNotImplemented());
}
template <>
- void enclosed_hyper_cube(Triangulation<2> &tria,
- const double left,
- const double right,
- const double thickness,
- const bool colorize)
+ void
+ enclosed_hyper_cube(Triangulation<2> &tria,
+ const double left,
+ const double right,
+ const double thickness,
+ const bool colorize)
{
Assert(left < right,
ExcMessage("Invalid left-to-right bounds of enclosed hypercube"));
// Implementation for 2D only
template <>
- void hyper_cube_slit(Triangulation<2> &tria,
- const double left,
- const double right,
- const bool colorize)
+ void
+ hyper_cube_slit(Triangulation<2> &tria,
+ const double left,
+ const double right,
+ const bool colorize)
{
const double rl2 = (right + left) / 2;
const Point<2> vertices[10] = {Point<2>(left, left),
template <>
- void truncated_cone(Triangulation<2> &triangulation,
- const double radius_0,
- const double radius_1,
- const double half_length)
+ void
+ truncated_cone(Triangulation<2> &triangulation,
+ const double radius_0,
+ const double radius_1,
+ const double half_length)
{
Point<2> vertices_tmp[4];
// Implementation for 2D only
template <>
- void hyper_L(Triangulation<2> &tria,
- const double a,
- const double b,
- const bool colorize)
+ void
+ hyper_L(Triangulation<2> &tria,
+ const double a,
+ const double b,
+ const bool colorize)
{
const Point<2> vertices[8] = {Point<2>(a, a),
Point<2>((a + b) / 2, a),
// Implementation for 2D only
template <>
- void hyper_ball(Triangulation<2> &tria,
- const Point<2> & p,
- const double radius,
- const bool internal_manifolds)
+ void
+ hyper_ball(Triangulation<2> &tria,
+ const Point<2> & p,
+ const double radius,
+ const bool internal_manifolds)
{
// equilibrate cell sizes at
// transition from the inner part
template <>
- void hyper_shell(Triangulation<2> & tria,
- const Point<2> & center,
- const double inner_radius,
- const double outer_radius,
- const unsigned int n_cells,
- const bool colorize)
+ void
+ hyper_shell(Triangulation<2> & tria,
+ const Point<2> & center,
+ const double inner_radius,
+ const double outer_radius,
+ const unsigned int n_cells,
+ const bool colorize)
{
Assert((inner_radius > 0) && (inner_radius < outer_radius),
ExcInvalidRadii());
// Implementation for 2D only
template <>
- void cylinder(Triangulation<2> &tria,
- const double radius,
- const double half_length)
+ void
+ cylinder(Triangulation<2> &tria,
+ const double radius,
+ const double half_length)
{
Point<2> p1(-half_length, -radius);
Point<2> p2(half_length, radius);
}
template <>
- void subdivided_cylinder(Triangulation<2> &,
- const unsigned int,
- const double,
- const double)
+ void
+ subdivided_cylinder(Triangulation<2> &,
+ const unsigned int,
+ const double,
+ const double)
{
Assert(false, ExcNotImplemented());
}
// Implementation for 2D only
template <>
- void cylinder_shell(Triangulation<2> &,
- const double,
- const double,
- const double,
- const unsigned int,
- const unsigned int)
+ void
+ cylinder_shell(Triangulation<2> &,
+ const double,
+ const double,
+ const double,
+ const unsigned int,
+ const unsigned int)
{
Assert(false, ExcNotImplemented());
}
template <>
- void quarter_hyper_ball(Triangulation<2> &tria,
- const Point<2> & p,
- const double radius)
+ void
+ quarter_hyper_ball(Triangulation<2> &tria,
+ const Point<2> & p,
+ const double radius)
{
const unsigned int dim = 2;
template <>
- void half_hyper_ball(Triangulation<2> &tria,
- const Point<2> & p,
- const double radius)
+ void
+ half_hyper_ball(Triangulation<2> &tria,
+ const Point<2> & p,
+ const double radius)
{
// equilibrate cell sizes at
// transition from the inner part
// Implementation for 2D only
template <>
- void half_hyper_shell(Triangulation<2> & tria,
- const Point<2> & center,
- const double inner_radius,
- const double outer_radius,
- const unsigned int n_cells,
- const bool colorize)
+ void
+ half_hyper_shell(Triangulation<2> & tria,
+ const Point<2> & center,
+ const double inner_radius,
+ const double outer_radius,
+ const unsigned int n_cells,
+ const bool colorize)
{
Assert((inner_radius > 0) && (inner_radius < outer_radius),
ExcInvalidRadii());
template <>
- void quarter_hyper_shell(Triangulation<2> & tria,
- const Point<2> & center,
- const double inner_radius,
- const double outer_radius,
- const unsigned int n_cells,
- const bool colorize)
+ void
+ quarter_hyper_shell(Triangulation<2> & tria,
+ const Point<2> & center,
+ const double inner_radius,
+ const double outer_radius,
+ const unsigned int n_cells,
+ const bool colorize)
{
Assert((inner_radius > 0) && (inner_radius < outer_radius),
ExcInvalidRadii());
// Implementation for 3D only
template <>
- void hyper_cube_slit(Triangulation<3> &tria,
- const double left,
- const double right,
- const bool colorize)
+ void
+ hyper_cube_slit(Triangulation<3> &tria,
+ const double left,
+ const double right,
+ const bool colorize)
{
const double rl2 = (right + left) / 2;
const double len = (right - left) / 2.;
// Implementation for 3D only
template <>
- void enclosed_hyper_cube(Triangulation<3> &tria,
- const double left,
- const double right,
- const double thickness,
- const bool colorize)
+ void
+ enclosed_hyper_cube(Triangulation<3> &tria,
+ const double left,
+ const double right,
+ const double thickness,
+ const bool colorize)
{
Assert(left < right,
ExcMessage("Invalid left-to-right bounds of enclosed hypercube"));
template <>
- void truncated_cone(Triangulation<3> &triangulation,
- const double radius_0,
- const double radius_1,
- const double half_length)
+ void
+ truncated_cone(Triangulation<3> &triangulation,
+ const double radius_0,
+ const double radius_1,
+ const double half_length)
{
Assert(triangulation.n_cells() == 0,
ExcMessage("The output triangulation object needs to be empty."));
// Implementation for 3D only
template <>
- void hyper_L(Triangulation<3> &tria,
- const double a,
- const double b,
- const bool colorize)
+ void
+ hyper_L(Triangulation<3> &tria,
+ const double a,
+ const double b,
+ const bool colorize)
{
// we slice out the top back right
// part of the cube
// Implementation for 3D only
template <>
- void hyper_ball(Triangulation<3> &tria,
- const Point<3> & p,
- const double radius,
- const bool internal_manifold)
+ void
+ hyper_ball(Triangulation<3> &tria,
+ const Point<3> & p,
+ const double radius,
+ const bool internal_manifold)
{
const double a =
1. / (1 + std::sqrt(3.0)); // equilibrate cell sizes at transition
}
- void non_standard_orientation_mesh(Triangulation<2> &tria,
- const bool rotate_left_square,
- const bool rotate_right_square)
+ void
+ non_standard_orientation_mesh(Triangulation<2> &tria,
+ const bool rotate_left_square,
+ const bool rotate_right_square)
{
constexpr unsigned int dim = 2;
}
- void non_standard_orientation_mesh(Triangulation<3> &tria,
- const bool face_orientation,
- const bool face_flip,
- const bool face_rotation,
- const bool manipulate_left_cube)
+ void
+ non_standard_orientation_mesh(Triangulation<3> &tria,
+ const bool face_orientation,
+ const bool face_flip,
+ const bool face_rotation,
+ const bool manipulate_left_cube)
{
constexpr unsigned int dim = 3;
template <int spacedim>
- void hyper_sphere(Triangulation<spacedim - 1, spacedim> &tria,
- const Point<spacedim> & p,
- const double radius)
+ void
+ hyper_sphere(Triangulation<spacedim - 1, spacedim> &tria,
+ const Point<spacedim> & p,
+ const double radius)
{
Triangulation<spacedim> volume_mesh;
GridGenerator::hyper_ball(volume_mesh, p, radius);
// Implementation for 3D only
template <>
- void subdivided_cylinder(Triangulation<3> & tria,
- const unsigned int x_subdivisions,
- const double radius,
- const double half_length)
+ void
+ subdivided_cylinder(Triangulation<3> & tria,
+ const unsigned int x_subdivisions,
+ const double radius,
+ const double half_length)
{
// Copy the base from hyper_ball<3>
// and transform it to yz
// Implementation for 3D only
template <>
- void cylinder(Triangulation<3> &tria,
- const double radius,
- const double half_length)
+ void
+ cylinder(Triangulation<3> &tria,
+ const double radius,
+ const double half_length)
{
subdivided_cylinder(tria, 2, radius, half_length);
}
template <>
- void quarter_hyper_ball(Triangulation<3> &tria,
- const Point<3> & center,
- const double radius)
+ void
+ quarter_hyper_ball(Triangulation<3> &tria,
+ const Point<3> & center,
+ const double radius)
{
const unsigned int dim = 3;
// Implementation for 3D only
template <>
- void half_hyper_ball(Triangulation<3> &tria,
- const Point<3> & center,
- const double radius)
+ void
+ half_hyper_ball(Triangulation<3> &tria,
+ const Point<3> & center,
+ const double radius)
{
// These are for the two lower squares
const double d = radius / std::sqrt(2.0);
template <>
- void hyper_shell(Triangulation<3> & tria,
- const Point<3> & p,
- const double inner_radius,
- const double outer_radius,
- const unsigned int n_cells,
- const bool colorize)
+ void
+ hyper_shell(Triangulation<3> & tria,
+ const Point<3> & p,
+ const double inner_radius,
+ const double outer_radius,
+ const unsigned int n_cells,
+ const bool colorize)
{
Assert((inner_radius > 0) && (inner_radius < outer_radius),
ExcInvalidRadii());
// Implementation for 3D only
template <>
- void half_hyper_shell(Triangulation<3> &tria,
- const Point<3> & center,
- const double inner_radius,
- const double outer_radius,
- const unsigned int /*n_cells*/,
- const bool colorize)
+ void
+ half_hyper_shell(Triangulation<3> &tria,
+ const Point<3> & center,
+ const double inner_radius,
+ const double outer_radius,
+ const unsigned int /*n_cells*/,
+ const bool colorize)
{
Assert((inner_radius > 0) && (inner_radius < outer_radius),
ExcInvalidRadii());
// Implementation for 3D only
template <>
- void quarter_hyper_shell(Triangulation<3> & tria,
- const Point<3> & center,
- const double inner_radius,
- const double outer_radius,
- const unsigned int n,
- const bool colorize)
+ void
+ quarter_hyper_shell(Triangulation<3> & tria,
+ const Point<3> & center,
+ const double inner_radius,
+ const double outer_radius,
+ const unsigned int n,
+ const bool colorize)
{
Assert((inner_radius > 0) && (inner_radius < outer_radius),
ExcInvalidRadii());
// Implementation for 3D only
template <>
- void cylinder_shell(Triangulation<3> & tria,
- const double length,
- const double inner_radius,
- const double outer_radius,
- const unsigned int n_radial_cells,
- const unsigned int n_axial_cells)
+ void
+ cylinder_shell(Triangulation<3> & tria,
+ const double length,
+ const double inner_radius,
+ const double outer_radius,
+ const unsigned int n_radial_cells,
+ const unsigned int n_axial_cells)
{
Assert((inner_radius > 0) && (inner_radius < outer_radius),
ExcInvalidRadii());
template <>
- void hyper_cube_with_cylindrical_hole(Triangulation<1> &,
- const double,
- const double,
- const double,
- const unsigned int,
- const bool)
+ void
+ hyper_cube_with_cylindrical_hole(Triangulation<1> &,
+ const double,
+ const double,
+ const double,
+ const unsigned int,
+ const bool)
{
Assert(false, ExcNotImplemented());
}
template <>
- void hyper_cube_with_cylindrical_hole(Triangulation<2> &triangulation,
- const double inner_radius,
- const double outer_radius,
- const double, // width,
- const unsigned int, // width_repetition,
- const bool colorize)
+ void
+ hyper_cube_with_cylindrical_hole(Triangulation<2> &triangulation,
+ const double inner_radius,
+ const double outer_radius,
+ const double, // width,
+ const unsigned int, // width_repetition,
+ const bool colorize)
{
const int dim = 2;
template <>
- void hyper_cube_with_cylindrical_hole(Triangulation<3> & triangulation,
- const double inner_radius,
- const double outer_radius,
- const double L,
- const unsigned int Nz,
- const bool colorize)
+ void
+ hyper_cube_with_cylindrical_hole(Triangulation<3> & triangulation,
+ const double inner_radius,
+ const double outer_radius,
+ const double L,
+ const unsigned int Nz,
+ const bool colorize)
{
const int dim = 3;
\{
#if deal_II_space_dimension >= 2
- template void hyper_sphere<deal_II_space_dimension>(
+ template void
+ hyper_sphere<deal_II_space_dimension>(
Triangulation<deal_II_space_dimension - 1, deal_II_space_dimension> &,
const Point<deal_II_space_dimension> &,
double);
// Write additional face information
if (write_faces)
- {
- }
+ {}
else
{}
#if deal_II_dimension < 3
template void
- GridRefinement::refine<deal_II_dimension, S, deal_II_dimension + 1>(
- Triangulation<deal_II_dimension, deal_II_dimension + 1> &,
- const dealii::Vector<S> &,
- const double,
- const unsigned int);
+ GridRefinement::refine<deal_II_dimension, S, deal_II_dimension + 1>(
+ Triangulation<deal_II_dimension, deal_II_dimension + 1> &,
+ const dealii::Vector<S> &,
+ const double,
+ const unsigned int);
template void
- GridRefinement::coarsen<deal_II_dimension, S, deal_II_dimension + 1>(
- Triangulation<deal_II_dimension, deal_II_dimension + 1> &,
- const dealii::Vector<S> &,
- const double);
+ GridRefinement::coarsen<deal_II_dimension, S, deal_II_dimension + 1>(
+ Triangulation<deal_II_dimension, deal_II_dimension + 1> &,
+ const dealii::Vector<S> &,
+ const double);
template void
- GridRefinement::refine_and_coarsen_fixed_number<deal_II_dimension,
- S,
- deal_II_dimension + 1>(
- Triangulation<deal_II_dimension, deal_II_dimension + 1> &,
- const dealii::Vector<S> &,
- const double,
- const double,
- const unsigned int);
+ GridRefinement::refine_and_coarsen_fixed_number<deal_II_dimension,
+ S,
+ deal_II_dimension + 1>(
+ Triangulation<deal_II_dimension, deal_II_dimension + 1> &,
+ const dealii::Vector<S> &,
+ const double,
+ const double,
+ const unsigned int);
template void
- GridRefinement::refine_and_coarsen_fixed_fraction<deal_II_dimension,
- S,
- deal_II_dimension + 1>(
- Triangulation<deal_II_dimension, deal_II_dimension + 1> &,
- const dealii::Vector<S> &,
- const double,
- const double,
- const unsigned int,
- const VectorTools::NormType);
+ GridRefinement::refine_and_coarsen_fixed_fraction<deal_II_dimension,
+ S,
+ deal_II_dimension + 1>(
+ Triangulation<deal_II_dimension, deal_II_dimension + 1> &,
+ const dealii::Vector<S> &,
+ const double,
+ const double,
+ const unsigned int,
+ const VectorTools::NormType);
template void GridRefinement::
refine_and_coarsen_optimize<deal_II_dimension, S, deal_II_dimension + 1>(
* do the reordering of their
* arguments in-place.
*/
- void reorder_new_to_old_style(std::vector<CellData<1>> &)
+ void
+ reorder_new_to_old_style(std::vector<CellData<1>> &)
{}
- void reorder_new_to_old_style(std::vector<CellData<2>> &cells)
+ void
+ reorder_new_to_old_style(std::vector<CellData<2>> &cells)
{
for (auto &cell : cells)
std::swap(cell.vertices[2], cell.vertices[3]);
}
- void reorder_new_to_old_style(std::vector<CellData<3>> &cells)
+ void
+ reorder_new_to_old_style(std::vector<CellData<3>> &cells)
{
unsigned int tmp[GeometryInfo<3>::vertices_per_cell];
for (auto &cell : cells)
/**
* And now also in the opposite direction.
*/
- void reorder_old_to_new_style(std::vector<CellData<1>> &)
+ void
+ reorder_old_to_new_style(std::vector<CellData<1>> &)
{}
- void reorder_old_to_new_style(std::vector<CellData<2>> &cells)
+ void
+ reorder_old_to_new_style(std::vector<CellData<2>> &cells)
{
// just invert the permutation:
reorder_new_to_old_style(cells);
}
- void reorder_old_to_new_style(std::vector<CellData<3>> &cells)
+ void
+ reorder_old_to_new_style(std::vector<CellData<3>> &cells)
{
// undo the ordering above
unsigned int tmp[GeometryInfo<3>::vertices_per_cell];
// overload of the function above for 1d -- there is nothing
// to orient in that case
- void reorient(std::vector<CellData<1>> &)
+ void
+ reorient(std::vector<CellData<1>> &)
{}
} // namespace
deal_II_dimension + 1>::active_cell_iterator);
template void
- GridTools::remove_hanging_nodes<deal_II_dimension, deal_II_dimension + 1>(
- Triangulation<deal_II_dimension, deal_II_dimension + 1> & tria,
- bool,
- unsigned int);
+ GridTools::remove_hanging_nodes<deal_II_dimension, deal_II_dimension + 1>(
+ Triangulation<deal_II_dimension, deal_II_dimension + 1> & tria,
+ bool,
+ unsigned int);
template void
- GridTools::remove_anisotropy<deal_II_dimension, deal_II_dimension + 1>(
- Triangulation<deal_II_dimension, deal_II_dimension + 1> &,
- double,
- unsigned int);
+ GridTools::remove_anisotropy<deal_II_dimension, deal_II_dimension + 1>(
+ Triangulation<deal_II_dimension, deal_II_dimension + 1> &,
+ double,
+ unsigned int);
#endif
}
const double layer_thickness)
{
std::vector<typename MeshType::active_cell_iterator>
- subdomain_boundary_cells, active_cell_layer_within_distance;
+ subdomain_boundary_cells, active_cell_layer_within_distance;
std::vector<bool> vertices_outside_subdomain(
mesh.get_triangulation().n_vertices(), false);
template <typename FaceIterator>
- inline bool orthogonal_equality(
+ inline bool
+ orthogonal_equality(
std::bitset<3> & orientation,
const FaceIterator & face1,
const FaceIterator & face2,
namespace GridTools
\{
- template bool orthogonal_equality<X::active_face_iterator>(
+ template bool
+ orthogonal_equality<X::active_face_iterator>(
std::bitset<3> &,
const X::active_face_iterator &,
const X::active_face_iterator &,
const Tensor<1, deal_II_space_dimension> &,
const FullMatrix<double> &);
- template bool orthogonal_equality<X::face_iterator>(
+ template bool
+ orthogonal_equality<X::face_iterator>(
std::bitset<3> &,
const X::face_iterator &,
const X::face_iterator &,
template <class MeshType>
-typename InterGridMap<MeshType>::cell_iterator InterGridMap<MeshType>::
- operator[](const cell_iterator &source_cell) const
+typename InterGridMap<MeshType>::cell_iterator
+InterGridMap<MeshType>::operator[](const cell_iterator &source_cell) const
{
Assert(source_cell.state() == IteratorState::valid,
ExcInvalidKey(source_cell));
}
boost::container::small_vector<std::pair<double, Tensor<1, spacedim>>, 100>
- new_candidates(new_points.size());
+ new_candidates(new_points.size());
boost::container::small_vector<Tensor<1, spacedim>, 100> directions(
surrounding_points.size(), Point<spacedim>());
boost::container::small_vector<double, 100> distances(
}
- void reorder_compatibility(std::vector<CellData<2>> &cells,
- const SubCellData &)
+ void
+ reorder_compatibility(std::vector<CellData<2>> &cells, const SubCellData &)
{
for (auto &cell : cells)
if (cell.vertices.size() == GeometryInfo<2>::vertices_per_cell)
}
- void reorder_compatibility(std::vector<CellData<3>> &cells,
- SubCellData & subcelldata)
+ void
+ reorder_compatibility(std::vector<CellData<3>> &cells,
+ SubCellData & subcelldata)
{
unsigned int tmp[GeometryInfo<3>::vertices_per_cell];
for (auto &cell : cells)
template <int spacedim>
- static void update_neighbors(Triangulation<1, spacedim> &)
+ static void
+ update_neighbors(Triangulation<1, spacedim> &)
{}
* argument and quads instead of lines.
*/
template <int spacedim>
- static void delete_children(
- Triangulation<1, spacedim> & triangulation,
- typename Triangulation<1, spacedim>::cell_iterator &cell,
- std::vector<unsigned int> &,
- std::vector<unsigned int> &)
+ static void
+ delete_children(Triangulation<1, spacedim> &triangulation,
+ typename Triangulation<1, spacedim>::cell_iterator &cell,
+ std::vector<unsigned int> &,
+ std::vector<unsigned int> &)
{
const unsigned int dim = 1;
template <int spacedim>
- static void delete_children(
- Triangulation<2, spacedim> & triangulation,
- typename Triangulation<2, spacedim>::cell_iterator &cell,
- std::vector<unsigned int> & line_cell_count,
- std::vector<unsigned int> &)
+ static void
+ delete_children(Triangulation<2, spacedim> &triangulation,
+ typename Triangulation<2, spacedim>::cell_iterator &cell,
+ std::vector<unsigned int> &line_cell_count,
+ std::vector<unsigned int> &)
{
const unsigned int dim = 2;
const RefinementCase<dim> ref_case = cell->refinement_case();
template <int spacedim>
- static void delete_children(
- Triangulation<3, spacedim> & triangulation,
- typename Triangulation<3, spacedim>::cell_iterator &cell,
- std::vector<unsigned int> & line_cell_count,
- std::vector<unsigned int> & quad_cell_count)
+ static void
+ delete_children(Triangulation<3, spacedim> &triangulation,
+ typename Triangulation<3, spacedim>::cell_iterator &cell,
+ std::vector<unsigned int> &line_cell_count,
+ std::vector<unsigned int> &quad_cell_count)
{
const unsigned int dim = 3;
* "before") the reserved space.
*/
template <int spacedim>
- static void create_children(
+ static void
+ create_children(
Triangulation<2, spacedim> &triangulation,
unsigned int & next_unused_vertex,
typename Triangulation<2, spacedim>::raw_line_iterator
*/
template <int spacedim>
static typename Triangulation<1, spacedim>::DistortedCellList
- execute_refinement(Triangulation<1, spacedim> &triangulation,
- const bool /*check_for_distorted_cells*/)
+ execute_refinement(Triangulation<1, spacedim> &triangulation,
+ const bool /*check_for_distorted_cells*/)
{
const unsigned int dim = 1;
*/
template <int spacedim>
static typename Triangulation<2, spacedim>::DistortedCellList
- execute_refinement(Triangulation<2, spacedim> &triangulation,
- const bool check_for_distorted_cells)
+ execute_refinement(Triangulation<2, spacedim> &triangulation,
+ const bool check_for_distorted_cells)
{
const unsigned int dim = 2;
template <int spacedim>
static typename Triangulation<3, spacedim>::DistortedCellList
- execute_refinement_isotropic(Triangulation<3, spacedim> &triangulation,
- const bool check_for_distorted_cells)
+ execute_refinement_isotropic(Triangulation<3, spacedim> &triangulation,
+ const bool check_for_distorted_cells)
{
static const int dim = 3;
static const unsigned int X = numbers::invalid_unsigned_int;
*/
template <int spacedim>
static typename Triangulation<3, spacedim>::DistortedCellList
- execute_refinement(Triangulation<3, spacedim> &triangulation,
- const bool check_for_distorted_cells)
+ execute_refinement(Triangulation<3, spacedim> &triangulation,
+ const bool check_for_distorted_cells)
{
const unsigned int dim = 3;
* specialization).
*/
template <int spacedim>
- static void prevent_distorted_boundary_cells(Triangulation<1, spacedim> &)
+ static void
+ prevent_distorted_boundary_cells(Triangulation<1, spacedim> &)
{}
template <int spacedim>
- static void prepare_refinement_dim_dependent(
+ static void
+ prepare_refinement_dim_dependent(
Triangulation<3, spacedim> &triangulation)
{
const unsigned int dim = 3;
struct ImplementationMixedMesh
{
template <int spacedim>
- static void update_neighbors(Triangulation<1, spacedim> &)
+ static void
+ update_neighbors(Triangulation<1, spacedim> &)
{}
template <int dim, int spacedim>
template <int dim, int spacedim>
Triangulation<dim, spacedim> &
-Triangulation<dim, spacedim>::
-operator=(Triangulation<dim, spacedim> &&tria) noexcept
+Triangulation<dim, spacedim>::operator=(
+ Triangulation<dim, spacedim> &&tria) noexcept
{
Subscriptor::operator=(std::move(tria));
template <class SparsityPatternBase>
BlockSparsityPatternBase<SparsityPatternBase> &
-BlockSparsityPatternBase<SparsityPatternBase>::
-operator=(const BlockSparsityPatternBase<SparsityPatternBase> &bsp)
+BlockSparsityPatternBase<SparsityPatternBase>::operator=(
+ const BlockSparsityPatternBase<SparsityPatternBase> &bsp)
{
Assert(rows == bsp.rows, ExcDimensionMismatch(rows, bsp.rows));
Assert(columns == bsp.columns, ExcDimensionMismatch(columns, bsp.columns));
template <typename Number>
- Number Vector<Number>::operator*(const VectorSpaceVector<Number> &V) const
+ Number
+ Vector<Number>::operator*(const VectorSpaceVector<Number> &V) const
{
// Check that casting will work
Assert(dynamic_cast<const Vector<Number> *>(&V) != nullptr,
- PetscScalar VectorBase::operator*(const VectorBase &vec) const
+ PetscScalar
+ VectorBase::operator*(const VectorBase &vec) const
{
Assert(size() == vec.size(), ExcDimensionMismatch(size(), vec.size()));
- double Vector::operator*(const VectorSpaceVector<double> &V) const
+ double
+ Vector::operator*(const VectorSpaceVector<double> &V) const
{
// Check that casting will work.
Assert(dynamic_cast<const Vector *>(&V) != nullptr,
(nonlocal_matrix.get() != nullptr &&
matrix->RowMap().MyGID(
static_cast<TrilinosWrappers::types::int_type>(row)) == false) ?
- &nonlocal_matrix->Graph() :
- &matrix->Graph();
+ &nonlocal_matrix->Graph() :
+ &matrix->Graph();
indices.resize(graph->NumGlobalIndices(row));
int n_indices = 0;
- TrilinosPayload operator*(const TrilinosPayload &first_op,
- const TrilinosPayload &second_op)
+ TrilinosPayload
+ operator*(const TrilinosPayload &first_op,
+ const TrilinosPayload &second_op)
{
using Domain = typename TrilinosPayload::Domain;
using Range = typename TrilinosPayload::Range;
// instantiate for integers:
template class Vector<int>;
-template Vector<double> &Vector<double>::
- operator=<int>(const dealii::Vector<int> &);
-template bool Vector<int>::operator==<int>(dealii::Vector<int> const &) const;
+template Vector<double> &
+Vector<double>::operator=<int>(const dealii::Vector<int> &);
+template bool
+Vector<int>::operator==<int>(dealii::Vector<int> const &) const;
template void
Vector<int>::reinit<double>(const Vector<double> &, const bool);
// instantiate for long double manually because we use it in a few places:
template class Vector<long double>;
-template long double Vector<long double>::
- operator*<long double>(const Vector<long double> &) const;
+template long double
+Vector<long double>::operator*<long double>(const Vector<long double> &) const;
// do a few functions that currently don't fit the scheme because they have
// two template arguments that need to be different (the case of same
std::vector<
std::vector<typename Triangulation<dim0, spacedim>::active_cell_iterator>>
- cell_container(n_active_c);
+ cell_container(n_active_c);
std::vector<std::vector<std::vector<Point<dim0>>>> qpoints_container(
n_active_c);
std::vector<std::vector<std::vector<unsigned int>>> maps_container(
n_postprocessor_outputs[dataset] = 0;
internal::DataOutRotationImplementation::ParallelData<dim, spacedim>
- thread_data(n_datasets,
+ thread_data(n_datasets,
n_subdivisions,
n_patches_per_circle,
n_postprocessor_outputs,
std::vector<std::vector<std::vector<Tensor<1, spacedim, number>>>>
gradients_neighbor(gradients_here);
std::vector<Vector<typename ProductType<number, double>::type>>
- grad_dot_n_neighbor(n_solution_vectors,
- Vector<typename ProductType<number, double>::type>(
- n_components));
+ grad_dot_n_neighbor(n_solution_vectors,
+ Vector<typename ProductType<number, double>::type>(
+ n_components));
// reserve some space for coefficient values at one point. if there is no
// coefficient, then we fill it by unity once and for all and don't set it
void
TimeDependent::end_sweep()
{
- parallel::apply_to_subranges(0U,
- timesteps.size(),
- [this](const unsigned int begin,
- const unsigned int end) {
- this->end_sweep(begin, end);
- },
- 1);
+ parallel::apply_to_subranges(
+ 0U,
+ timesteps.size(),
+ [this](const unsigned int begin, const unsigned int end) {
+ this->end_sweep(begin, end);
+ },
+ 1);
}
TopExp_Explorer exp;
unsigned int n_faces = 0, n_edges = 0, n_vertices = 0;
for (exp.Init(shape, TopAbs_FACE); exp.More(); exp.Next(), ++n_faces)
- {
- }
+ {}
for (exp.Init(shape, TopAbs_EDGE); exp.More(); exp.Next(), ++n_edges)
- {
- }
+ {}
for (exp.Init(shape, TopAbs_VERTEX); exp.More(); exp.Next(), ++n_vertices)
- {
- }
+ {}
return std::tuple<unsigned int, unsigned int, unsigned int>(n_faces,
n_edges,
n_vertices);
template <int dim, int spacedim>
Particle<dim, spacedim> &
- Particle<dim, spacedim>::
- operator=(Particle<dim, spacedim> &&particle) noexcept
+ Particle<dim, spacedim>::operator=(
+ Particle<dim, spacedim> &&particle) noexcept
{
if (this != &particle)
{
update_quadrature_points |
update_JxW_values | update_normal_vectors);
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
DoFHandler<3> dof_handler(tria);
dof_handler.distribute_dofs(fe);
// perform the usual check, i.e. first refine a single cell (anisotropically),
// then global refinement, then global coarsening. For each step, check, that
// quadrature points both on faces and neighboring subfaces match.
-void check(Triangulation<3> &tria_org)
+void
+check(Triangulation<3> &tria_org)
{
for (unsigned int c = 0; c < tria_org.n_active_cells(); ++c)
for (unsigned int i = 1; i < 8; ++i)
// perform an additional check: simulate an isotropic refinement of a given cell
// via several anisotropic refinements. Then, perform the usual checks. This
// went wrong at some time, so check that it works now.
-void check2(Triangulation<3> &orig_tria)
+void
+check2(Triangulation<3> &orig_tria)
{
for (unsigned int i = 0; i < orig_tria.n_active_cells(); ++i)
{
const unsigned int num_arnoldi_vectors = 2 * eigenvalues.size() + 2;
PArpackSolver<LinearAlgebra::distributed::Vector<double>>::AdditionalData
- additional_data(num_arnoldi_vectors,
- PArpackSolver<LinearAlgebra::distributed::Vector<double>>::
- largest_magnitude,
- true);
+ additional_data(
+ num_arnoldi_vectors,
+ PArpackSolver<
+ LinearAlgebra::distributed::Vector<double>>::largest_magnitude,
+ true);
SolverControl solver_control(dof_handler.n_dofs(),
1e-9,
const unsigned int num_arnoldi_vectors = 2 * eigenvalues.size() + 40;
PArpackSolver<LinearAlgebra::distributed::Vector<double>>::AdditionalData
- additional_data(num_arnoldi_vectors,
- PArpackSolver<LinearAlgebra::distributed::Vector<double>>::
- largest_magnitude,
- true,
- 2);
+ additional_data(
+ num_arnoldi_vectors,
+ PArpackSolver<
+ LinearAlgebra::distributed::Vector<double>>::largest_magnitude,
+ true,
+ 2);
SolverControl solver_control(dof_handler.n_dofs(),
1e-10,
const unsigned int num_arnoldi_vectors = 2 * eigenvalues.size() + 10;
PArpackSolver<LinearAlgebra::distributed::Vector<double>>::AdditionalData
- additional_data(num_arnoldi_vectors,
- PArpackSolver<LinearAlgebra::distributed::Vector<double>>::
- largest_magnitude,
- true,
- 1);
+ additional_data(
+ num_arnoldi_vectors,
+ PArpackSolver<
+ LinearAlgebra::distributed::Vector<double>>::largest_magnitude,
+ true,
+ 1);
SolverControl solver_control(dof_handler.n_dofs(),
1e-9,
constexpr unsigned int n_data_points_per_cell = 4;
-void setup_history(
- Triangulation<2> &tria,
- CellDataStorage<typename Triangulation<2>::active_cell_iterator, MaterialBase>
- &storage)
+void
+setup_history(Triangulation<2> & tria,
+ CellDataStorage<typename Triangulation<2>::active_cell_iterator,
+ MaterialBase> &storage)
{
deallog << "initializing history" << std::endl;
for (auto cell : tria.active_cell_iterators())
}
}
-void read_history(
- Triangulation<2> &tria,
- CellDataStorage<typename Triangulation<2>::active_cell_iterator, MaterialBase>
- &storage)
+void
+read_history(Triangulation<2> & tria,
+ CellDataStorage<typename Triangulation<2>::active_cell_iterator,
+ MaterialBase> &storage)
{
deallog << "reading history" << std::endl;
for (auto cell : tria.active_cell_iterators())
}
std::vector<Vector<double>> values(points.size(),
- Vector<double>(f.n_components));
+ Vector<double>(f.n_components));
std::vector<std::vector<double>> values2(f.n_components,
std::vector<double>(points.size()));
f.vector_value_list(points, values);
template <int dim>
struct FillTensor<1, dim>
{
- static void fill_tensor(Tensor<1, dim> &tensor, int base)
+ static void
+ fill_tensor(Tensor<1, dim> &tensor, int base)
{
for (int i = 0; i < dim; ++i)
tensor[i] = 10 * base + i;
}
std::vector<Vector<double>> values(points.size(),
- Vector<double>(f.n_components));
+ Vector<double>(f.n_components));
std::vector<std::vector<double>> values2(f.n_components,
std::vector<double>(points.size()));
f.vector_value_list(points, values);
}
// set z=x+2y, which happens to be zero
- parallel::transform(x.begin(),
- x.end(),
- y.begin(),
- z.begin(),
- [](double i, double j) { return i + 2 * j; },
- 10);
+ parallel::transform(
+ x.begin(),
+ x.end(),
+ y.begin(),
+ z.begin(),
+ [](double i, double j) { return i + 2 * j; },
+ 10);
Assert(z.l2_norm() == 0, ExcInternalError());
// set a=x+y-z, which happens to be
// zero
- parallel::transform(x.begin(),
- x.end(),
- y.begin(),
- z.begin(),
- a.begin(),
- [](double i, double j, double k) { return i + j - k; },
- 10);
+ parallel::transform(
+ x.begin(),
+ x.end(),
+ y.begin(),
+ z.begin(),
+ a.begin(),
+ [](double i, double j, double k) { return i + j - k; },
+ 10);
AssertThrow(a.l2_norm() == 0, ExcInternalError());
#include "../tests.h"
template <int dim>
-void check_line(Quadrature<1> &quadrature)
+void
+check_line(Quadrature<1> &quadrature)
{
Point<dim> p1;
Point<dim> p2;
}
template <int dim>
-void check_face(Quadrature<1> &q1)
+void
+check_face(Quadrature<1> &q1)
{
deallog << "Checking dim " << dim << " 1d-points " << q1.size() << std::endl;
}
template <int dim>
-void check_faces(Quadrature<1> &q1)
+void
+check_faces(Quadrature<1> &q1)
{
const unsigned int nq = q1.size();
}
-void check(Quadrature<1> &q)
+void
+check(Quadrature<1> &q)
{
deallog << std::endl;
deallog.push("line");
template <class Quad, typename... Args>
std::string
-check_q_move(Args &&... args)
+check_q_move(Args &&...args)
{
Quad quad1(args...);
const unsigned int size1 = quad1.size();
template <template <int dim> class Quad, typename... Args>
void
-check_quadrature_move(Args &&... args)
+check_quadrature_move(Args &&...args)
{
deallog << check_q_move<Quad<1>>(std::forward<Args>(args)...) << 1 << " "
<< check_q_move<Quad<2>>(std::forward<Args>(args)...) << 2 << " "
template <template <int dim> class Quad, int dim, typename... Args>
std::string
-check_q_assign_move(Args &&... args)
+check_q_assign_move(Args &&...args)
{
Quad<dim> quad1(args...);
const unsigned int size1 = quad1.size();
template <template <int dim> class Quad, typename... Args>
void
-check_quadrature_assign_move(Args &&... args)
+check_quadrature_assign_move(Args &&...args)
{
deallog << check_q_assign_move<Quad, 1>(std::forward<Args>(args)...) << 1
<< " " << check_q_assign_move<Quad, 2>(std::forward<Args>(args)...)
std::string s = ss.str();
std::replace_if(s.begin(), s.end(), ::isdigit, ' ');
- std::replace_if(s.begin(), s.end(), [](char x) { return x == '.'; }, ' ');
+ std::replace_if(
+ s.begin(), s.end(), [](char x) { return x == '.'; }, ' ');
deallog << s << std::endl << std::endl;
}
std::string s = ss.str();
std::replace_if(s.begin(), s.end(), ::isdigit, ' ');
- std::replace_if(s.begin(), s.end(), [](char x) { return x == '.'; }, ' ');
+ std::replace_if(
+ s.begin(), s.end(), [](char x) { return x == '.'; }, ' ');
deallog << s << std::endl << std::endl;
}
std::string s = ss.str();
std::replace_if(s.begin(), s.end(), ::isdigit, ' ');
- std::replace_if(s.begin(), s.end(), [](char x) { return x == '.'; }, ' ');
+ std::replace_if(
+ s.begin(), s.end(), [](char x) { return x == '.'; }, ' ');
deallog << s << std::endl << std::endl;
}
std::string s = ss.str();
std::replace_if(s.begin(), s.end(), ::isdigit, ' ');
- std::replace_if(s.begin(), s.end(), [](char x) { return x == '.'; }, ' ');
+ std::replace_if(
+ s.begin(), s.end(), [](char x) { return x == '.'; }, ' ');
deallog << s << std::endl << std::endl;
}
return Point<dim>(-p[1], p[0], p[2]);
}
-void set_manifold(Triangulation<2> &triangulation)
+void
+set_manifold(Triangulation<2> &triangulation)
{}
-void set_manifold(Triangulation<3> &triangulation)
+void
+set_manifold(Triangulation<3> &triangulation)
{
static const CylindricalManifold<3> boundary(1);
triangulation.set_manifold(0, boundary);
return Point<dim>(-p[2], p[1], p[0]);
}
-void set_manifold(Triangulation<3> &triangulation)
+void
+set_manifold(Triangulation<3> &triangulation)
{
static const CylindricalManifold<3> boundary(2);
triangulation.set_manifold(0, boundary);
-void check(Triangulation<2> &tria)
+void
+check(Triangulation<2> &tria)
{
Point<2> p(1. / 3., 1. / 2. - 1e-10); // avoid ambiguity for hypercube mesh
-void create_coarse_grid(Triangulation<2> &coarse_grid)
+void
+create_coarse_grid(Triangulation<2> &coarse_grid)
{
static const Point<2> vertices_1[] = {
Point<2>(9.6982181981258408e-02, 1.1255621492491609e+03), // 0
#include "../tests.h"
-void check(Triangulation<2> &tria)
+void
+check(Triangulation<2> &tria)
{
// generate some random points bounded by [0., 0.2)^2 in R^2 space
// any point in this domain should be inside one of the cells
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
Point<3> p(1. / 3., 1. / 2., 1. / 5.);
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
Point<3> p(1. / 3., 1. / 2., -1. / 5.);
#include "../tests.h"
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
Point<3> p(0.75, 0, 0);
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
Point<3> p(0.75, 0.75, 0.75);
#include "../tests.h"
-bool inside(Triangulation<3> &tria, Point<3> &p)
+bool
+inside(Triangulation<3> &tria, Point<3> &p)
{
for (Triangulation<3>::cell_iterator cell = tria.begin(0);
cell != tria.end(0);
#include "../tests.h"
-bool inside(Triangulation<3> &tria, Point<3> &p)
+bool
+inside(Triangulation<3> &tria, Point<3> &p)
{
for (Triangulation<3>::cell_iterator cell = tria.begin(0);
cell != tria.end(0);
#include "../tests.h"
-void create_coarse_grid(Triangulation<2> &coarse_grid)
+void
+create_coarse_grid(Triangulation<2> &coarse_grid)
{
static const Point<2> vertices_1[] = {
Point<2>(0., 0.), // 0
}
-void check(Triangulation<2> &tria)
+void
+check(Triangulation<2> &tria)
{
Point<2> p(0.99, 1. / 2.);
#include "../tests.h"
-void create_coarse_grid(Triangulation<2> &coarse_grid)
+void
+create_coarse_grid(Triangulation<2> &coarse_grid)
{
static const Point<2> vertices_1[] = {
Point<2>(0., 0.), // 0
}
-void check(Triangulation<2> &tria)
+void
+check(Triangulation<2> &tria)
{
Point<2> p(0.99, 1. / 2.);
-void check(Triangulation<2> &tria)
+void
+check(Triangulation<2> &tria)
{
MappingQ<2> map(3); // Let's take a higher order mapping
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
MappingQ<3> map(3);
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
MappingQ<3> map(3);
#include "../tests.h"
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
MappingQ<3> map(1);
#include "../tests.h"
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
MappingQ<3> map(1);
Point<3> p(0.75, 0.75, 0.75);
-void check(Triangulation<2> &tria)
+void
+check(Triangulation<2> &tria)
{
const std::vector<Point<2>> &v = tria.get_vertices();
MappingQ<2> map(1);
-void check(Triangulation<2> &tria)
+void
+check(Triangulation<2> &tria)
{
MappingQ<2> map(5);
-void check(Triangulation<2> &tria)
+void
+check(Triangulation<2> &tria)
{
for (unsigned i = 0; i < tria.n_vertices(); i++)
{
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
for (unsigned i = 0; i < tria.n_vertices(); i++)
{
-void check(Triangulation<2> &tria)
+void
+check(Triangulation<2> &tria)
{
for (unsigned i = 0; i < tria.n_vertices(); i++)
{
-void check(Triangulation<2> &tria)
+void
+check(Triangulation<2> &tria)
{
for (unsigned i = 0; i < tria.n_vertices(); i++)
{
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
for (unsigned i = 0; i < tria.n_vertices(); i++)
{
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
for (unsigned i = 0; i < tria.n_vertices(); i++)
{
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
const std::vector<Point<3>> &v = tria.get_vertices();
for (unsigned i = 0; i < v.size(); i++)
// not a, as it should. Simply looking at the identity of the neighboring cell
// is not enough, we have to look at the (index of the) face instead.
-void create_grid(Triangulation<2> &tria)
+void
+create_grid(Triangulation<2> &tria)
{
const unsigned int n_points = 5;
-void create_two_cubes(Triangulation<3> &coarse_grid)
+void
+create_two_cubes(Triangulation<3> &coarse_grid)
{
const Point<3> points[6] = {Point<3>(0, 0, 0),
Point<3>(1, 0, 0),
}
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
QGauss<2> quadrature(3);
FE_Q<3> fe(1);
Assert(cell->active_cell_index() == index, ExcInternalError());
}
-void do_refine(Triangulation<1> &tria)
+void
+do_refine(Triangulation<1> &tria)
{
const int dim = 1;
}
-void do_refine(Triangulation<2> &tria)
+void
+do_refine(Triangulation<2> &tria)
{
const int dim = 2;
}
-void do_refine(Triangulation<3> &tria)
+void
+do_refine(Triangulation<3> &tria)
{
const int dim = 3;
-void do_refine(Triangulation<1> &tria)
+void
+do_refine(Triangulation<1> &tria)
{
tria.refine_global(2);
tria.begin_active()->set_refine_flag();
}
-void do_refine(Triangulation<2> &tria)
+void
+do_refine(Triangulation<2> &tria)
{
const int dim = 2;
}
-void do_refine(Triangulation<3> &tria)
+void
+do_refine(Triangulation<3> &tria)
{
const int dim = 3;
-void do_refine(Triangulation<1> &tria)
+void
+do_refine(Triangulation<1> &tria)
{
tria.refine_global(2);
tria.begin_active()->set_refine_flag();
}
-void do_refine(Triangulation<2> &tria)
+void
+do_refine(Triangulation<2> &tria)
{
const int dim = 2;
}
-void do_refine(Triangulation<3> &tria)
+void
+do_refine(Triangulation<3> &tria)
{
const int dim = 3;
-void do_refine(Triangulation<1> &tria)
+void
+do_refine(Triangulation<1> &tria)
{
tria.refine_global(2);
tria.begin_active()->set_refine_flag();
}
-void do_refine(Triangulation<2> &tria)
+void
+do_refine(Triangulation<2> &tria)
{
const int dim = 2;
}
-void do_refine(Triangulation<3> &tria)
+void
+do_refine(Triangulation<3> &tria)
{
const int dim = 3;
-void do_refine(Triangulation<1> &tria)
+void
+do_refine(Triangulation<1> &tria)
{
tria.refine_global(2);
tria.begin_active()->set_refine_flag();
}
-void do_refine(Triangulation<2> &tria)
+void
+do_refine(Triangulation<2> &tria)
{
const int dim = 2;
}
-void do_refine(Triangulation<3> &tria)
+void
+do_refine(Triangulation<3> &tria)
{
const int dim = 3;
-void do_refine(Triangulation<1> &tria)
+void
+do_refine(Triangulation<1> &tria)
{
const int dim = 1;
}
-void do_refine(Triangulation<2> &tria)
+void
+do_refine(Triangulation<2> &tria)
{
const int dim = 2;
}
-void do_refine(Triangulation<3> &tria)
+void
+do_refine(Triangulation<3> &tria)
{
const int dim = 3;
-void do_refine(Triangulation<1> &tria)
+void
+do_refine(Triangulation<1> &tria)
{
tria.refine_global(2);
tria.begin_active()->set_refine_flag();
}
-void do_refine(Triangulation<2> &tria)
+void
+do_refine(Triangulation<2> &tria)
{
const int dim = 2;
}
-void do_refine(Triangulation<3> &tria)
+void
+do_refine(Triangulation<3> &tria)
{
const int dim = 3;
-void do_refine(Triangulation<1> &tria)
+void
+do_refine(Triangulation<1> &tria)
{
tria.refine_global(2);
tria.begin_active()->set_refine_flag();
}
-void do_refine(Triangulation<2> &tria)
+void
+do_refine(Triangulation<2> &tria)
{
const int dim = 2;
}
-void do_refine(Triangulation<3> &tria)
+void
+do_refine(Triangulation<3> &tria)
{
const int dim = 3;
#include "../tests.h"
-void evaluate_normal(DoFHandler<2> &dof_handler, Vector<double> &solution)
+void
+evaluate_normal(DoFHandler<2> &dof_handler, Vector<double> &solution)
{
// This quadrature rule determines
// the points, where the continuity
template <int dim>
void
- PointXDerivativeEvaluation<dim>::
- operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ PointXDerivativeEvaluation<dim>::operator()(
+ const DoFHandler<dim> &dof_handler,
+ const Vector<double> & solution) const
{
double point_derivative = 0;
template <>
- void Exercise_2_3<2>::create_coarse_grid(Triangulation<2> &coarse_grid)
+ void
+ Exercise_2_3<2>::create_coarse_grid(Triangulation<2> &coarse_grid)
{
const unsigned int dim = 2;
for (unsigned int t = 0;
(t < this_thread) && (cell != dual_solver.dof_handler.end());
++t, ++cell)
- {
- }
+ {}
if (cell == dual_solver.dof_handler.end())
for (unsigned int t = 0;
((t < n_threads) && (cell != dual_solver.dof_handler.end()));
++t, ++cell, ++cell_index)
- {
- }
+ {}
if (cell == dual_solver.dof_handler.end())
break;
std::ofstream logfile("output");
-void make_grid(Triangulation<2> &triangulation)
+void
+make_grid(Triangulation<2> &triangulation)
{
const Point<2> center(1, 0);
const double inner_radius = 0.5, outer_radius = 1.0;
}
-void distribute_dofs(DoFHandler<2> &dof_handler)
+void
+distribute_dofs(DoFHandler<2> &dof_handler)
{
static const FE_Q<2> finite_element(1);
dof_handler.distribute_dofs(finite_element);
-void renumber_dofs(DoFHandler<2> &dof_handler)
+void
+renumber_dofs(DoFHandler<2> &dof_handler)
{
DoFRenumbering::Cuthill_McKee(dof_handler);
SparsityPattern sparsity_pattern(dof_handler.n_dofs(), dof_handler.n_dofs());
}
-double integration(Point<3> point)
+double
+integration(Point<3> point)
{
Triangulation<2, 3> square;
GridGenerator::hyper_cube<2, 3>(square, 0, 2);
-void cylinder(Triangulation<3> &tria,
- const double radius = 1,
- const double half_length = 1)
+void
+cylinder(Triangulation<3> &tria,
+ const double radius = 1,
+ const double half_length = 1)
{
// Copy the base from hyper_ball<3>
// and transform it to yz
}
template <int b>
-void fill_tensor_2(Tensor<2, b> &T)
+void
+fill_tensor_2(Tensor<2, b> &T)
{
for (unsigned int i = 0; i < b; i++)
for (unsigned int j = 0; j < b; j++)
template <int b>
-void display_tensor_2(Tensor<2, b> &T)
+void
+display_tensor_2(Tensor<2, b> &T)
{
deallog << b << "x" << b << " tensor" << std::endl;
for (unsigned int i = 0; i < b; i++)
template <int dim, int fe_degree>
__device__ void
-DummyOperator<dim, fe_degree>::
-operator()(const unsigned int cell,
- const typename CUDAWrappers::MatrixFree<dim, double>::Data *gpu_data,
- CUDAWrappers::SharedData<dim, double> *,
- const double *,
- double *dst) const
+DummyOperator<dim, fe_degree>::operator()(
+ const unsigned int cell,
+ const typename CUDAWrappers::MatrixFree<dim, double>::Data *gpu_data,
+ CUDAWrappers::SharedData<dim, double> *,
+ const double *,
+ double *dst) const
{
const unsigned int pos = CUDAWrappers::local_q_point_id<dim, double>(
cell, gpu_data, n_dofs_1d, n_q_points);
#include <iostream>
-void create_mesh(Triangulation<2> &tria, const double scale_grid = 1.)
+void
+create_mesh(Triangulation<2> &tria, const double scale_grid = 1.)
{
const unsigned int dim = 2;
std::vector<Point<dim>> points(12);
-void create_mesh(Triangulation<3> &tria, const double scale_grid = 1.)
+void
+create_mesh(Triangulation<3> &tria, const double scale_grid = 1.)
{
const unsigned int dim = 3;
std::vector<Point<dim>> points(24);
deallog << "norm_square: " << t.norm_square() << std::endl;
}
-__global__ void init_kernel(Tensor<2, 3> *t, const unsigned int N)
+__global__ void
+init_kernel(Tensor<2, 3> *t, const unsigned int N)
{
const unsigned int i = threadIdx.y;
const unsigned int j = threadIdx.x;
(*t)[i][j] = j + i * N + 1.;
}
-__global__ void norm_kernel(Tensor<2, 3> *t, double *norm, double *norm_square)
+__global__ void
+norm_kernel(Tensor<2, 3> *t, double *norm, double *norm_square)
{
if (threadIdx.x == 0)
{
}
template <int dim, typename Number>
-__global__ void init_kernel(Tensor<0, dim, Number> *t)
+__global__ void
+init_kernel(Tensor<0, dim, Number> *t)
{
if (threadIdx.x == 0)
*t = 1.;
}
template <int dim, typename Number>
-__global__ void init_kernel(Tensor<1, dim, Number> *t)
+__global__ void
+init_kernel(Tensor<1, dim, Number> *t)
{
const unsigned int i = threadIdx.x;
if (i < dim)
}
template <int dim, typename Number>
-__global__ void init_kernel(Tensor<2, dim, Number> *t)
+__global__ void
+init_kernel(Tensor<2, dim, Number> *t)
{
const unsigned int i = threadIdx.y;
const unsigned int j = threadIdx.x;
fe_degree,
Number,
LinearAlgebra::distributed::Vector<Number, MemorySpace::CUDA>>
- mf(mf_data, coef_size);
+ mf(mf_data, coef_size);
LinearAlgebra::distributed::Vector<Number, MemorySpace::CUDA> in_dev;
LinearAlgebra::distributed::Vector<Number, MemorySpace::CUDA> out_dev;
mf_data.initialize_dof_vector(in_dev);
fe_degree,
Number,
LinearAlgebra::distributed::Vector<Number, MemorySpace::CUDA>>
- mf(mf_data, coef_size);
+ mf(mf_data, coef_size);
LinearAlgebra::distributed::Vector<Number, MemorySpace::CUDA> in_dev(
owned_set, MPI_COMM_WORLD);
LinearAlgebra::distributed::Vector<Number, MemorySpace::CUDA> out_dev(
fe_degree,
Number,
LinearAlgebra::distributed::Vector<Number, MemorySpace::CUDA>>
- mf(mf_data, coef_size);
+ mf(mf_data, coef_size);
LinearAlgebra::distributed::Vector<Number, MemorySpace::CUDA> in_dev;
LinearAlgebra::distributed::Vector<Number, MemorySpace::CUDA> out_dev;
mf_data.initialize_dof_vector(in_dev);
: coef(coef)
{}
- __device__ void operator()(
+ __device__ void
+ operator()(
CUDAWrappers::FEEvaluation<dim, fe_degree, n_q_points_1d, 1, Number>
*fe_eval) const;
template <int dim, int fe_degree, typename Number, int n_q_points_1d>
-__device__ void HelmholtzOperatorQuad<dim, fe_degree, Number, n_q_points_1d>::
- operator()(CUDAWrappers::FEEvaluation<dim, fe_degree, n_q_points_1d, 1, Number>
- *fe_eval) const
+__device__ void
+HelmholtzOperatorQuad<dim, fe_degree, Number, n_q_points_1d>::operator()(
+ CUDAWrappers::FEEvaluation<dim, fe_degree, n_q_points_1d, 1, Number> *fe_eval)
+ const
{
fe_eval->submit_value(coef * fe_eval->get_value());
fe_eval->submit_gradient(fe_eval->get_gradient());
template <int dim, int fe_degree, typename Number, int n_q_points_1d>
__device__ void
-HelmholtzOperator<dim, fe_degree, Number, n_q_points_1d>::
-operator()(const unsigned int cell,
- const typename CUDAWrappers::MatrixFree<dim, Number>::Data *gpu_data,
- CUDAWrappers::SharedData<dim, Number> *shared_data,
- const Number * src,
- Number * dst) const
+HelmholtzOperator<dim, fe_degree, Number, n_q_points_1d>::operator()(
+ const unsigned int cell,
+ const typename CUDAWrappers::MatrixFree<dim, Number>::Data *gpu_data,
+ CUDAWrappers::SharedData<dim, Number> * shared_data,
+ const Number * src,
+ Number * dst) const
{
const unsigned int pos = CUDAWrappers::local_q_point_id<dim, Number>(
cell, gpu_data, n_dofs_1d, n_q_points);
template <int dim, int fe_degree, typename Number, int n_q_points_1d>
__device__ void
-VaryingCoefficientFunctor<dim, fe_degree, Number, n_q_points_1d>::
-operator()(const unsigned int cell,
- const typename CUDAWrappers::MatrixFree<dim, Number>::Data *gpu_data)
+VaryingCoefficientFunctor<dim, fe_degree, Number, n_q_points_1d>::operator()(
+ const unsigned int cell,
+ const typename CUDAWrappers::MatrixFree<dim, Number>::Data *gpu_data)
{
const unsigned int pos = CUDAWrappers::local_q_point_id<dim, Number>(
cell, gpu_data, n_dofs_1d, n_q_points);
CUDAWrappers::SparseMatrix<double> A_diagonal_inverse_dev(cuda_handle,
A_diagonal_inverse);
RelaxationOperator<CUDAWrappers::SparseMatrix<double>>
- relaxation_operator_dev(A_dev, A_diagonal_inverse_dev);
+ relaxation_operator_dev(A_dev, A_diagonal_inverse_dev);
LinearAlgebra::CUDAWrappers::Vector<double> sol_dev(size);
LinearAlgebra::CUDAWrappers::Vector<double> rhs_dev(size);
LinearAlgebra::ReadWriteVector<double> rw_vector(size);
*/
/* The 2D case */
-void generate_grid(Triangulation<2> &triangulation, int orientation)
+void
+generate_grid(Triangulation<2> &triangulation, int orientation)
{
Point<2> vertices_1[] = {
Point<2>(-1., -3.),
}
/* The 2D in 3D case */
-void generate_grid(Triangulation<2, 3> &triangulation, int orientation)
+void
+generate_grid(Triangulation<2, 3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {
Point<3>(-1., -3., 0.),
}
/* The 3D case */
-void generate_grid(Triangulation<3> &triangulation, int orientation)
+void
+generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
Point<3>(+1., -1., -3.),
*/
/* The 2D case */
-void generate_grid(Triangulation<2> &triangulation)
+void
+generate_grid(Triangulation<2> &triangulation)
{
Point<2> vertices_1[] = {
Point<2>(-1., -3.),
}
/* The 2D in 3D case */
-void generate_grid(Triangulation<2, 3> &triangulation)
+void
+generate_grid(Triangulation<2, 3> &triangulation)
{
Point<3> vertices_1[] = {
Point<3>(-1., -3., 0.),
*/
/* The 2D case */
-void generate_grid(Triangulation<2> &triangulation)
+void
+generate_grid(Triangulation<2> &triangulation)
{
Point<2> vertices_1[] = {
Point<2>(-1., -3.),
}
/* The 2D in 3D case */
-void generate_grid(Triangulation<2, 3> &triangulation)
+void
+generate_grid(Triangulation<2, 3> &triangulation)
{
Point<3> vertices_1[] = {
Point<3>(-1., -3., 0.),
*/
/* The 2D case */
-void generate_grid(Triangulation<2> &triangulation)
+void
+generate_grid(Triangulation<2> &triangulation)
{
Point<2> vertices_1[] = {
Point<2>(-1., -3.),
}
/* The 2D in 3D case */
-void generate_grid(Triangulation<2, 3> &triangulation)
+void
+generate_grid(Triangulation<2, 3> &triangulation)
{
Point<3> vertices_1[] = {
Point<3>(-1., -3., 0.),
*/
/* The 2D case */
-void generate_grid(Triangulation<2> &triangulation, int orientation)
+void
+generate_grid(Triangulation<2> &triangulation, int orientation)
{
Point<2> vertices_1[] = {
Point<2>(-1., -3.),
}
/* The 2D in 3D case */
-void generate_grid(Triangulation<2, 3> &triangulation, int orientation)
+void
+generate_grid(Triangulation<2, 3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {
Point<3>(-1., -3., 0.),
}
/* The 3D case */
-void generate_grid(Triangulation<3> &triangulation, int orientation)
+void
+generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
Point<3>(+1., -1., -3.),
* Create the 3-cells-triangulation (described at the top) by first creating 2
* cells one the same level and then refining the right one.
*/
-void create_3_elements_on_2_different_levels(Triangulation<1> &triangulation)
+void
+create_3_elements_on_2_different_levels(Triangulation<1> &triangulation)
{
const unsigned int n_elements = 3;
GridGenerator::subdivided_hyper_cube(triangulation, n_elements - 1);
// Create the 3-cell-triangulation described at the top.
-void create_3_cell_triangulation(Triangulation<1> &triangulation)
+void
+create_3_cell_triangulation(Triangulation<1> &triangulation)
{
const unsigned int n_elements = 3;
const double left = -1;
}
-void set_boundary_ids(Triangulation<1> &)
+void
+set_boundary_ids(Triangulation<1> &)
{}
-void set_boundary_ids(Triangulation<1> &)
+void
+set_boundary_ids(Triangulation<1> &)
{}
* Check the value of the derivative field.
*/
-double TestProjection(Mapping<2> &mapping, DoFHandler<2> *dof_handler)
+double
+TestProjection(Mapping<2> &mapping, DoFHandler<2> *dof_handler)
{
Vector<double> solution;
solution.reinit(dof_handler->n_dofs());
template <int dim>
void
- PointXDerivativeEvaluation<dim>::
- operator()(const DoFHandler<dim> &dof_handler,
- const Vector<double> & solution) const
+ PointXDerivativeEvaluation<dim>::operator()(
+ const DoFHandler<dim> &dof_handler,
+ const Vector<double> & solution) const
{
double point_derivative = 0;
template <>
- void Exercise_2_3<2>::create_coarse_grid(Triangulation<2> &coarse_grid)
+ void
+ Exercise_2_3<2>::create_coarse_grid(Triangulation<2> &coarse_grid)
{
const unsigned int dim = 2;
* Integrate the function value over the element.
*/
-double EvaluateArea(Mapping<2> & mapping,
- DoFHandler<2> * dof_handler,
- Vector<double> &solution)
+double
+EvaluateArea(Mapping<2> & mapping,
+ DoFHandler<2> * dof_handler,
+ Vector<double> &solution)
{
// Use a high order quadrature.
QGauss<2> quad(6);
* Check the value of the derivative field.
*/
-double EvaluateDiver(Mapping<2> & mapping,
- DoFHandler<2> & dof_handler,
- Vector<double> &solution)
+double
+EvaluateDiver(Mapping<2> & mapping,
+ DoFHandler<2> & dof_handler,
+ Vector<double> &solution)
{
// Use a high order quadrature.
QGauss<2> quad(6);
* Check the value of the derivative field.
*/
-void EvaluateDerivative(DoFHandler<2> *dof_handler, Vector<double> &solution)
+void
+EvaluateDerivative(DoFHandler<2> *dof_handler, Vector<double> &solution)
{
// This quadrature rule determines the points, where the
// derivative will be evaluated.
}
-int create_alternate_unitsquare(Triangulation<2> &tria)
+int
+create_alternate_unitsquare(Triangulation<2> &tria)
{
std::vector<Point<2>> points;
* Check the value of the derivative field.
*/
-void EvaluateDerivative(DoFHandler<3> &dof_handler, Vector<double> &solution)
+void
+EvaluateDerivative(DoFHandler<3> &dof_handler, Vector<double> &solution)
{
// This quadrature rule determines the points, where the
// derivative will be evaluated.
}
-void transform_grid(Triangulation<2> &tria, const unsigned int transform)
+void
+transform_grid(Triangulation<2> &tria, const unsigned int transform)
{
switch (transform)
{
* Check the value of the derivative field.
*/
-double TestProjection(Mapping<2> &mapping, DoFHandler<2> *dof_handler)
+double
+TestProjection(Mapping<2> &mapping, DoFHandler<2> *dof_handler)
{
Vector<double> solution;
solution.reinit(dof_handler->n_dofs());
* Check the value of the derivative field.
*/
-void EvaluateDerivative(DoFHandler<2> *dof_handler, Vector<double> &solution)
+void
+EvaluateDerivative(DoFHandler<2> *dof_handler, Vector<double> &solution)
{
// This quadrature rule determines the points, where the
// derivative will be evaluated.
}
-void plot_shapes(DoFHandler<2> &dof_handler)
+void
+plot_shapes(DoFHandler<2> &dof_handler)
{
Vector<double> solution(dof_handler.n_dofs());
std::set<unsigned int> face_dofs;
-void test_2d_3d(std::vector<FiniteElement<1> *> &fe_datas)
+void
+test_2d_3d(std::vector<FiniteElement<1> *> &fe_datas)
{}
void
print();
- void set_enrichment_point(Point<2> &p, const unsigned int i)
+ void
+ set_enrichment_point(Point<2> &p, const unsigned int i)
{
AssertDimension(dim, 2);
p(0) = points_enrichments[2 * i];
p(1) = points_enrichments[2 * i + 1];
}
- void set_enrichment_point(Point<3> &p, const unsigned int i)
+ void
+ set_enrichment_point(Point<3> &p, const unsigned int i)
{
AssertDimension(dim, 3);
p(0) = points_enrichments[3 * i];
#include "../tests.h"
-void create_reference_triangulation(Triangulation<3> &tria)
+void
+create_reference_triangulation(Triangulation<3> &tria)
{
std::vector<unsigned int> repetitions(3, 1);
Point<3>(1.0, 1.0, 1.0));
}
-void create_triangulation(Triangulation<3> &tria,
- const bool face_orientation,
- const bool face_flip,
- const bool face_rotation)
+void
+create_triangulation(Triangulation<3> &tria,
+ const bool face_orientation,
+ const bool face_flip,
+ const bool face_rotation)
{
std::vector<CellData<3>> cells(2);
#include "../tests.h"
-void create_reference_triangulation(Triangulation<3> &triangulation)
+void
+create_reference_triangulation(Triangulation<3> &triangulation)
{
GridGenerator::hyper_cube(triangulation, -1.0, 1.0);
triangulation.refine_global(1);
}
-void create_triangulation(Triangulation<3> &triangulation)
+void
+create_triangulation(Triangulation<3> &triangulation)
{
static const Point<3> vertices_parallelograms[] = {
Point<3>(-1., -1., -1.), // 0
#include "../tests.h"
-void create_reference_triangulation(Triangulation<3> &tria)
+void
+create_reference_triangulation(Triangulation<3> &tria)
{
std::vector<unsigned int> repetitions(3, 1);
Point<3>(1.0, 1.0, 1.0));
}
-void create_triangulation(Triangulation<3> &tria,
- const bool face_orientation,
- const bool face_flip,
- const bool face_rotation)
+void
+create_triangulation(Triangulation<3> &tria,
+ const bool face_orientation,
+ const bool face_flip,
+ const bool face_rotation)
{
std::vector<CellData<3>> cells(2);
values(i) = value(p, i);
}
-void create_tria(Triangulation<2> &triangulation,
- const Point<2> * vertices_parallelograms)
+void
+create_tria(Triangulation<2> &triangulation,
+ const Point<2> * vertices_parallelograms)
{
const std::vector<Point<2>> vertices(&vertices_parallelograms[0],
&vertices_parallelograms[n_vertices]);
return val;
}
-void create_tria(Triangulation<3> &triangulation,
- const Point<3> * vertices_parallelograms)
+void
+create_tria(Triangulation<3> &triangulation,
+ const Point<3> * vertices_parallelograms)
{
const std::vector<Point<3>> vertices(&vertices_parallelograms[0],
&vertices_parallelograms[n_vertices]);
deallog << std::endl;
}
-void resize(Table<2, double> &coeff, const unsigned int N)
+void
+resize(Table<2, double> &coeff, const unsigned int N)
{
coeff.reinit(N, N);
}
-void resize(Table<3, double> &coeff, const unsigned int N)
+void
+resize(Table<3, double> &coeff, const unsigned int N)
{
TableIndices<3> size;
for (unsigned int d = 0; d < 3; d++)
-void make_grid(Triangulation<2> &triangulation)
+void
+make_grid(Triangulation<2> &triangulation)
{
GridGenerator::hyper_cube(triangulation);
}
-void transform_grid(Triangulation<2> &tria, const unsigned int transform)
+void
+transform_grid(Triangulation<2> &tria, const unsigned int transform)
{
switch (transform)
{
}
-void transform_grid(Triangulation<2> &tria, const unsigned int transform)
+void
+transform_grid(Triangulation<2> &tria, const unsigned int transform)
{
switch (transform)
{
* Check the value of the derivative field.
*/
-double TestProjection(Mapping<2> &mapping, DoFHandler<2> *dof_handler)
+double
+TestProjection(Mapping<2> &mapping, DoFHandler<2> *dof_handler)
{
Vector<double> solution;
solution.reinit(dof_handler->n_dofs());
-void transform_grid(Triangulation<2> &tria, const unsigned int transform)
+void
+transform_grid(Triangulation<2> &tria, const unsigned int transform)
{
switch (transform)
{
* Check if the normal component is continuous over element edges.
*/
-void EvaluateNormal2(DoFHandler<2> *dof_handler, Vector<double> &solution)
+void
+EvaluateNormal2(DoFHandler<2> *dof_handler, Vector<double> &solution)
{
// This quadrature rule determines the points, where the
// continuity will be tested.
* Check if the normal component is continuous over element edges.
*/
-void EvaluateNormal(DoFHandler<2> *dof_handler, Vector<double> &solution)
+void
+EvaluateNormal(DoFHandler<2> *dof_handler, Vector<double> &solution)
{
// This quadrature rule determines the points, where the
// continuity will be tested.
template <>
-void plot_face_shape_functions(Mapping<1> &,
- FiniteElement<1> &,
- const char *,
- UpdateFlags)
+void
+plot_face_shape_functions(Mapping<1> &,
+ FiniteElement<1> &,
+ const char *,
+ UpdateFlags)
{}
make_2_cells(Triangulation<dim> &tria);
template <>
-void make_2_cells<2>(Triangulation<2> &tria)
+void
+make_2_cells<2>(Triangulation<2> &tria)
{
const unsigned int dim = 2;
std::vector<unsigned int> repetitions = {2, 1};
}
template <>
-void make_2_cells<3>(Triangulation<3> &tria)
+void
+make_2_cells<3>(Triangulation<3> &tria)
{
const unsigned int dim = 3;
std::vector<unsigned int> repetitions = {2, 1, 1};
make_2_cells(Triangulation<dim> &tria);
template <>
-void make_2_cells<2>(Triangulation<2> &tria)
+void
+make_2_cells<2>(Triangulation<2> &tria)
{
const unsigned int dim = 2;
std::vector<unsigned int> repetitions = {2, 1};
}
template <>
-void make_2_cells<3>(Triangulation<3> &tria)
+void
+make_2_cells<3>(Triangulation<3> &tria)
{
const unsigned int dim = 3;
std::vector<unsigned int> repetitions = {2, 1, 1};
make_2_cells(Triangulation<dim> &tria);
template <>
-void make_2_cells<2>(Triangulation<2> &tria)
+void
+make_2_cells<2>(Triangulation<2> &tria)
{
const unsigned int dim = 2;
std::vector<unsigned int> repetitions = {2, 1};
}
template <>
-void make_2_cells<3>(Triangulation<3> &tria)
+void
+make_2_cells<3>(Triangulation<3> &tria)
{
const unsigned int dim = 3;
std::vector<unsigned int> repetitions = {2, 1, 1};
make_2_cells(Triangulation<dim> &tria);
template <>
-void make_2_cells<2>(Triangulation<2> &tria)
+void
+make_2_cells<2>(Triangulation<2> &tria)
{
const unsigned int dim = 2;
std::vector<unsigned int> repetitions = {2, 1};
}
template <>
-void make_2_cells<3>(Triangulation<3> &tria)
+void
+make_2_cells<3>(Triangulation<3> &tria)
{
const unsigned int dim = 3;
std::vector<unsigned int> repetitions = {2, 1, 1};
make_2_cells(Triangulation<dim> &tria);
template <>
-void make_2_cells<2>(Triangulation<2> &tria)
+void
+make_2_cells<2>(Triangulation<2> &tria)
{
const unsigned int dim = 2;
std::vector<unsigned int> repetitions = {2, 1};
}
template <>
-void make_2_cells<3>(Triangulation<3> &tria)
+void
+make_2_cells<3>(Triangulation<3> &tria)
{
const unsigned int dim = 3;
std::vector<unsigned int> repetitions = {2, 1, 1};
make_2_cells(Triangulation<dim> &tria);
template <>
-void make_2_cells<2>(Triangulation<2> &tria)
+void
+make_2_cells<2>(Triangulation<2> &tria)
{
const unsigned int dim = 2;
std::vector<unsigned int> repetitions = {2, 1};
}
template <>
-void make_2_cells<3>(Triangulation<3> &tria)
+void
+make_2_cells<3>(Triangulation<3> &tria)
{
const unsigned int dim = 3;
std::vector<unsigned int> repetitions = {2, 1, 1};
make_2_cells(Triangulation<dim> &tria);
template <>
-void make_2_cells<2>(Triangulation<2> &tria)
+void
+make_2_cells<2>(Triangulation<2> &tria)
{
const unsigned int dim = 2;
std::vector<unsigned int> repetitions = {2, 1};
}
template <>
-void make_2_cells<3>(Triangulation<3> &tria)
+void
+make_2_cells<3>(Triangulation<3> &tria)
{
const unsigned int dim = 3;
std::vector<unsigned int> repetitions = {2, 1, 1};
template <>
-void make_2_cells<2>(Triangulation<2> &tria)
+void
+make_2_cells<2>(Triangulation<2> &tria)
{
const unsigned int dim = 2;
std::vector<unsigned int> repetitions = {2, 1};
template <>
-void make_2_cells<3>(Triangulation<3> &tria)
+void
+make_2_cells<3>(Triangulation<3> &tria)
{
const unsigned int dim = 3;
std::vector<unsigned int> repetitions = {2, 1, 1};
deallog << std::endl;
}
-void make_2_cells(Triangulation<2> &tria)
+void
+make_2_cells(Triangulation<2> &tria)
{
const unsigned int dim = 2;
std::vector<unsigned int> repetitions = {2, 1};
GridGenerator::subdivided_hyper_rectangle(tria, repetitions, p1, p2);
}
-void make_2_cells(Triangulation<3> &tria)
+void
+make_2_cells(Triangulation<3> &tria)
{
const unsigned int dim = 3;
std::vector<unsigned int> repetitions = {2, 1, 1};
-void setup_tria(Triangulation<1> &tria)
+void
+setup_tria(Triangulation<1> &tria)
{
GridGenerator::subdivided_hyper_rectangle(
tria, std::vector<unsigned int>(5u, 1), Point<1>(), Point<1>(1.5), true);
-void my_cylinder(Triangulation<3> &tria,
- const double radius,
- const double half_length)
+void
+my_cylinder(Triangulation<3> &tria,
+ const double radius,
+ const double half_length)
{
// Copy the base from hyper_ball<3>
// and transform it to yz
namespace GridGenerator
{
template <int dim, typename VectorType>
- void create_triangulation_with_marching_cube_algorithm(
+ void
+ create_triangulation_with_marching_cube_algorithm(
Triangulation<dim - 1, dim> &tria,
const Mapping<dim> & mapping,
const DoFHandler<dim> & background_dof_handler,
#include "../tests.h"
// overloads to get multiple grids for multiple dim and spacedim combinations
-void make_grid(Triangulation<2, 2> &triangulation)
+void
+make_grid(Triangulation<2, 2> &triangulation)
{
GridGenerator::hyper_shell(triangulation, Point<2>(), 2.0, 6.0, 12);
}
-void make_grid(Triangulation<2, 3> &triangulation)
+void
+make_grid(Triangulation<2, 3> &triangulation)
{
GridGenerator::hyper_sphere(triangulation, Point<3>(), 6.0);
triangulation.refine_global(1); // need more cells
}
-void make_grid(Triangulation<3, 3> &triangulation)
+void
+make_grid(Triangulation<3, 3> &triangulation)
{
GridGenerator::hyper_shell(triangulation, Point<3>(), 2.0, 6.0, 12);
triangulation.refine_global(0);
};
// overloads to get multiple grids for multiple dim and spacedim combinations
-void make_grid(Triangulation<2, 2> &triangulation)
+void
+make_grid(Triangulation<2, 2> &triangulation)
{
GridGenerator::hyper_shell(triangulation, Point<2>(), 2.0, 6.0, 12);
}
-void make_grid(Triangulation<2, 3> &triangulation)
+void
+make_grid(Triangulation<2, 3> &triangulation)
{
GridGenerator::hyper_sphere(triangulation, Point<3>(), 6.0);
triangulation.refine_global(1); // need more cells
}
-void make_grid(Triangulation<3, 3> &triangulation)
+void
+make_grid(Triangulation<3, 3> &triangulation)
{
GridGenerator::hyper_shell(triangulation, Point<3>(), 2.0, 6.0, 12);
triangulation.refine_global(0);
*/
/* The 2D case */
-void generate_grid(Triangulation<2> &triangulation)
+void
+generate_grid(Triangulation<2> &triangulation)
{
Point<2> vertices_1[] = {
Point<2>(-1., -3.),
/* The 3D case */
-void generate_grid(Triangulation<3> &triangulation)
+void
+generate_grid(Triangulation<3> &triangulation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
Point<3>(+1., -1., -3.),
*/
/* The 2D case */
-void generate_grid(Triangulation<2> &triangulation, int orientation)
+void
+generate_grid(Triangulation<2> &triangulation, int orientation)
{
Point<2> vertices_1[] = {
Point<2>(-1., -3.),
/* The 3D case */
-void generate_grid(Triangulation<3> &triangulation, int orientation)
+void
+generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
Point<3>(+1., -1., -3.),
step_sizes.push_back(step_sizes_i);
const Point<dim> bottom_left;
- const Point<dim> upper_right =
- dim == 1 ? Point<dim>(size) :
- dim == 2 ? Point<dim>(size, size) : Point<dim>(size, size, size);
+ const Point<dim> upper_right = dim == 1 ? Point<dim>(size) :
+ dim == 2 ? Point<dim>(size, size) :
+ Point<dim>(size, size, size);
Triangulation<dim> tria;
GridGenerator::subdivided_hyper_rectangle(
trans_func(Point<dim> &p);
template <>
-Point<2> trans_func(Point<2> &p)
+Point<2>
+trans_func(Point<2> &p)
{
Point<2> r(p(0) + p(1) * p(1), p(1));
return r;
}
template <>
-Point<3> trans_func(Point<3> &p)
+Point<3>
+trans_func(Point<3> &p)
{
Point<3> r(p(0) + p(1) * p(1), p(1), p(2));
return r;
// to all cells, thus n_cells are neighboring at this line. in delete_children,
// this is not accounted for (for n_cells>5) and the child lines are deleted,
// although they are still needed.
-void create_star_structured_cylinder(Triangulation<3> & coarse_grid,
- const unsigned int n_cells)
+void
+create_star_structured_cylinder(Triangulation<3> & coarse_grid,
+ const unsigned int n_cells)
{
Assert(n_cells > 1, ExcNotImplemented());
// move backward two adjacent vertices of the top face up by one
// unit. all faces remain flat this way
-Point<3> distort_planar(Point<3> p)
+Point<3>
+distort_planar(Point<3> p)
{
if (p(1) > 0.5 && p(2) > 0.5)
{
// lift two opposite vertices of the top face up by one unit to create
// a saddle surface
-Point<3> distort_twisted(Point<3> p)
+Point<3>
+distort_twisted(Point<3> p)
{
if (p(2) > 0.5 && ((p(0) > 0.5) ^ (p(1) > 0.5)))
{
// match up for the standard orientation of the normals. we thus have
// to store the face orientation in each cell
-void create_two_cubes(Triangulation<3> &coarse_grid)
+void
+create_two_cubes(Triangulation<3> &coarse_grid)
{
const Point<3> points[6] = {Point<3>(0, 0, 0),
Point<3>(1, 0, 0),
// the edges are not all ok and the common face is rotated. we thus have
// to store the face rotation (and face flip) in each cell
-void create_two_cubes_rotation(Triangulation<3> & coarse_grid,
- const unsigned int n_rotations)
+void
+create_two_cubes_rotation(Triangulation<3> & coarse_grid,
+ const unsigned int n_rotations)
{
Assert(n_rotations < 4, ExcNotImplemented());
-void create_L_shape(Triangulation<3> &coarse_grid)
+void
+create_L_shape(Triangulation<3> &coarse_grid)
{
std::vector<Point<3>> vertices;
std::vector<CellData<3>> cells;
}
-void coarsen_global(Triangulation<3> &grid)
+void
+coarsen_global(Triangulation<3> &grid)
{
for (Triangulation<3>::active_cell_iterator c = grid.begin_active();
c != grid.end();
#include "mesh_3d.h"
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
for (Triangulation<3>::cell_iterator cell = tria.begin(); cell != tria.end();
++cell)
}
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
deallog << "Initial check" << std::endl;
check_this(tria);
#include "mesh_3d.h"
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
for (Triangulation<3>::cell_iterator cell = tria.begin(); cell != tria.end();
++cell)
}
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
deallog << "Initial check" << std::endl;
check_this(tria);
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
FE_Q<3> fe(1);
DoFHandler<3> dof_handler(tria);
}
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
(++tria.begin_active())->set_refine_flag();
tria.execute_coarsening_and_refinement();
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
Triangulation<3>::active_cell_iterator cell = tria.begin_active();
for (; cell != tria.end(); ++cell)
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
(++tria.begin_active())->set_refine_flag();
tria.execute_coarsening_and_refinement();
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
QTrapezoid<2> quadrature;
FE_Q<3> fe(1);
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
(++tria.begin_active())->set_refine_flag();
tria.execute_coarsening_and_refinement();
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
FE_Q<3> fe(1);
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
(++tria.begin_active())->set_refine_flag();
tria.execute_coarsening_and_refinement();
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
FE_Q<3> fe(1);
DoFHandler<3> dof_handler(tria);
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
deallog << "Coarse cell 0 vertices:" << std::endl;
for (unsigned int i = 0; i < 8; ++i)
#include "../grid/mesh_3d.h"
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
QTrapezoid<2> quadrature;
FE_Q<3> fe(1);
}
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
deallog << "Initial check" << std::endl;
check_this(tria);
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
FE_Q<3> fe(1);
DoFHandler<3> dof_handler(tria);
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
(++tria.begin_active())->set_refine_flag();
tria.execute_coarsening_and_refinement();
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
const unsigned int initial_count = count_wrong_faces(tria);
for (unsigned int r = 0; r < 3; ++r)
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
// look at all faces, not only
// active ones
}
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
deallog << "Initial check" << std::endl;
check_this(tria);
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
QMidpoint<2> q;
FE_Q<3> fe(1);
}
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
deallog << "Initial check" << std::endl;
check_this(tria);
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
QTrapezoid<2> quadrature;
FE_Q<3> fe(1);
}
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
deallog << "Initial check" << std::endl;
check_this(tria);
#include "mesh_3d.h"
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
for (Triangulation<3>::cell_iterator cell = tria.begin(); cell != tria.end();
++cell)
}
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
deallog << "Initial check" << std::endl;
check_this(tria);
#include "mesh_3d.h"
-void check_this(Triangulation<3> &tria)
+void
+check_this(Triangulation<3> &tria)
{
for (Triangulation<3>::cell_iterator cell = tria.begin(); cell != tria.end();
++cell)
}
-void check(Triangulation<3> &tria)
+void
+check(Triangulation<3> &tria)
{
deallog << "Initial check" << std::endl;
check_this(tria);
std::vector<types::global_dof_index> dofs_per_block;
Triangulation<dim>
- triangulation; // a triangulation object of the "dim"-dimensional domain;
+ triangulation; // a triangulation object of the "dim"-dimensional domain;
DoFHandler<dim> dof_handler; // is associated with triangulation;
FESystem<dim> elasticity_fe;
-void make_grid(Triangulation<2> &triangulation)
+void
+make_grid(Triangulation<2> &triangulation)
{
const Point<2> center(1, 0);
const double inner_radius = 0.5, outer_radius = 1.0;
}
-void distribute_dofs(DoFHandler<2> &dof_handler)
+void
+distribute_dofs(DoFHandler<2> &dof_handler)
{
static const hp::FECollection<2> finite_element(FE_Q<2>(1));
dof_handler.distribute_dofs(finite_element);
-void renumber_dofs(DoFHandler<2> &dof_handler)
+void
+renumber_dofs(DoFHandler<2> &dof_handler)
{
DoFRenumbering::Cuthill_McKee(dof_handler);
SparsityPattern sparsity_pattern(dof_handler.n_dofs(), dof_handler.n_dofs());
std::ofstream logfile("output");
-void make_tria(Triangulation<3> &tria, int step)
+void
+make_tria(Triangulation<3> &tria, int step)
{
switch (step)
{
{
template <typename Number>
template <typename Number2>
- Number Vector<Number>::operator*(const Vector<Number2> &v) const
+ Number
+ Vector<Number>::operator*(const Vector<Number2> &v) const
{
Number sum = 0;
for (unsigned int i = 0; i < size(); ++i)
{
template <typename Number>
template <typename Number2>
- Number Vector<Number>::operator*(const Vector<Number2> &v) const
+ Number
+ Vector<Number>::operator*(const Vector<Number2> &v) const
{
Number sum = 0;
for (unsigned int i = 0; i < size(); ++i)
const unsigned int num_arnoldi_vectors = 2 * eigenvalues.size() + 10;
PArpackSolver<LinearAlgebra::distributed::Vector<double>>::AdditionalData
- additional_data(num_arnoldi_vectors,
- PArpackSolver<LinearAlgebra::distributed::Vector<double>>::
- largest_magnitude,
- true,
- 1);
+ additional_data(
+ num_arnoldi_vectors,
+ PArpackSolver<
+ LinearAlgebra::distributed::Vector<double>>::largest_magnitude,
+ true,
+ 1);
SolverControl solver_control(dof_handler.n_dofs(),
1e-10,
//
// Eccentricity must be in range ]0,1[
//
- void build_simple_hyper_shell(Triangulation<2, 2> &grid,
- const Point<2> & center,
- const double inner_radius,
- const double outer_radius,
- const double eccentricity)
+ void
+ build_simple_hyper_shell(Triangulation<2, 2> &grid,
+ const Point<2> & center,
+ const double inner_radius,
+ const double outer_radius,
+ const double eccentricity)
{
unsigned int cell[][4] = {{5, 6, 0, 1},
{6, 7, 1, 2},
std::vector<double> radius;
};
-void concentric_disks(Triangulation<2> & tria,
- const double s,
- const std::vector<double> &x,
- Geom_parameters & gp)
+void
+concentric_disks(Triangulation<2> & tria,
+ const double s,
+ const std::vector<double> &x,
+ Geom_parameters & gp)
{
double r = x[0], d = 0.5 * x[0],
q = 1.0 / sqrt(2.0); // q: corner points factor
// --------------------------------------------------------------------------------
}
-void concentric_disks(Triangulation<2> & tria,
- std::vector<double> x,
- Geom_parameters & gp)
+void
+concentric_disks(Triangulation<2> & tria,
+ std::vector<double> x,
+ Geom_parameters & gp)
{
concentric_disks(tria, 0.0, x, gp);
}
template <>
-inline void plot_faces(Mapping<1> &,
- FiniteElement<1> &,
- DoFHandler<1>::cell_iterator &,
- const std::string &)
+inline void
+plot_faces(Mapping<1> &,
+ FiniteElement<1> &,
+ DoFHandler<1>::cell_iterator &,
+ const std::string &)
{}
template <>
-inline void plot_subfaces(Mapping<1> &,
- FiniteElement<1> &,
- DoFHandler<1>::cell_iterator &,
- const std::string &)
+inline void
+plot_subfaces(Mapping<1> &,
+ FiniteElement<1> &,
+ DoFHandler<1>::cell_iterator &,
+ const std::string &)
{}
template <>
-void create_triangulations(std::vector<Triangulation<1> *> &tria_ptr,
- std::vector<Manifold<1> *> &,
- std::vector<double> &exact_areas)
+void
+create_triangulations(std::vector<Triangulation<1> *> &tria_ptr,
+ std::vector<Manifold<1> *> &,
+ std::vector<double> &exact_areas)
{
show.resize(1, std::vector<unsigned int>(mapping_size, 0));
Triangulation<1> *tria = new Triangulation<1>();
template <>
-void create_triangulations(std::vector<Triangulation<2> *> &tria_ptr,
- std::vector<Manifold<2> *> & boundary_ptr,
- std::vector<double> & exact_areas)
+void
+create_triangulations(std::vector<Triangulation<2> *> &tria_ptr,
+ std::vector<Manifold<2> *> & boundary_ptr,
+ std::vector<double> & exact_areas)
{
Triangulation<2> *tria;
show.clear();
template <>
-void create_triangulations(std::vector<Triangulation<3> *> &tria_ptr,
- std::vector<Manifold<3> *> & boundary_ptr,
- std::vector<double> & exact_areas)
+void
+create_triangulations(std::vector<Triangulation<3> *> &tria_ptr,
+ std::vector<Manifold<3> *> & boundary_ptr,
+ std::vector<double> & exact_areas)
{
Triangulation<3> *tria;
show.clear();
initlog();
do_test<2>(3, Solution<2>(true), true);
do_test<2>(3, Solution<2>(false), false);
- do_test<2>(3,
- [](const typename Triangulation<2>::cell_iterator &,
- const Point<2> &p) -> Point<2> {
- Point<2> result;
-
- for (unsigned int compontent = 0; compontent < 2; ++compontent)
- result[compontent] =
- std::sin(p[compontent] * 0.5 * numbers::PI) - p[compontent];
-
- return result;
- },
- true);
- do_test<2>(3,
- [](const typename Triangulation<2>::cell_iterator &,
- const Point<2> &p) -> Point<2> {
- Point<2> result;
-
- for (unsigned int compontent = 0; compontent < 2; ++compontent)
- result[compontent] =
- std::sin(p[compontent] * 0.5 * numbers::PI);
-
- return result;
- },
- false);
+ do_test<2>(
+ 3,
+ [](const typename Triangulation<2>::cell_iterator &,
+ const Point<2> &p) -> Point<2> {
+ Point<2> result;
+
+ for (unsigned int compontent = 0; compontent < 2; ++compontent)
+ result[compontent] =
+ std::sin(p[compontent] * 0.5 * numbers::PI) - p[compontent];
+
+ return result;
+ },
+ true);
+ do_test<2>(
+ 3,
+ [](const typename Triangulation<2>::cell_iterator &,
+ const Point<2> &p) -> Point<2> {
+ Point<2> result;
+
+ for (unsigned int compontent = 0; compontent < 2; ++compontent)
+ result[compontent] = std::sin(p[compontent] * 0.5 * numbers::PI);
+
+ return result;
+ },
+ false);
}
const unsigned int MANIFOLD_ID = 1;
-void create_triangulation(Triangulation<2> &tria)
+void
+create_triangulation(Triangulation<2> &tria)
{
AssertThrow(std::abs((X_2 - X_1) - 2.0 * (X_C - X_1)) < 1.0e-12,
ExcMessage("Geometry parameters X_1,X_2,X_C invalid!"));
}
}
-void create_triangulation(Triangulation<3> &tria)
+void
+create_triangulation(Triangulation<3> &tria)
{
Triangulation<2> tria_2d;
create_triangulation(tria_2d);
(number)(std::max(1, fe_degree) * (fe_degree + 1.0)) * 2.;
std::array<types::boundary_id, VectorizedArray<number>::size()>
- boundary_ids = data.get_faces_by_cells_boundary_id(cell, face);
+ boundary_ids = data.get_faces_by_cells_boundary_id(cell, face);
VectorizedArray<number> factor_boundary;
for (unsigned int v = 0; v < VectorizedArray<number>::size(); ++v)
// interior face
#include <iostream>
-void create_mesh(Triangulation<2> &tria, const double scale_grid = 1.)
+void
+create_mesh(Triangulation<2> &tria, const double scale_grid = 1.)
{
const unsigned int dim = 2;
std::vector<Point<dim>> points(12);
-void create_mesh(Triangulation<3> &tria, const double scale_grid = 1.)
+void
+create_mesh(Triangulation<3> &tria, const double scale_grid = 1.)
{
const unsigned int dim = 3;
std::vector<Point<dim>> points(24);
template <int dim, int fe_degree, typename Number>
void
-MatrixFreeTest<dim, fe_degree, Number>::
-operator()(const MatrixFree<dim, Number> &data,
- VectorType &,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> &cell_range) const
+MatrixFreeTest<dim, fe_degree, Number>::operator()(
+ const MatrixFree<dim, Number> &data,
+ VectorType &,
+ const VectorType & src,
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval2(data);
template <int dim, int fe_degree, typename Number>
void
-MatrixFreeTest<dim, fe_degree, Number>::
-operator()(const MatrixFree<dim, Number> &data,
- VectorType &,
- const VectorType & src,
- const std::pair<unsigned int, unsigned int> &cell_range) const
+MatrixFreeTest<dim, fe_degree, Number>::operator()(
+ const MatrixFree<dim, Number> &data,
+ VectorType &,
+ const VectorType & src,
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval2(data);
template <int dim, int fe_degree, typename Number>
void
-MatrixFreeTest<dim, fe_degree, Number>::
-operator()(const MatrixFree<dim, Number> &data,
- std::vector<Vector<Number> *> &dst,
- const std::vector<Vector<Number> *> &,
- const std::pair<unsigned int, unsigned int> &cell_range) const
+MatrixFreeTest<dim, fe_degree, Number>::operator()(
+ const MatrixFree<dim, Number> &data,
+ std::vector<Vector<Number> *> &dst,
+ const std::vector<Vector<Number> *> &,
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval(data);
const unsigned int n_q_points = fe_eval.n_q_points;
template <int dim, int fe_degree, typename Number>
void
-MatrixFreeTest<dim, fe_degree, Number>::
-operator()(const MatrixFree<dim, Number> &data,
- std::vector<Vector<Number>> & dst,
- const std::vector<Vector<Number>> &,
- const std::pair<unsigned int, unsigned int> &cell_range) const
+MatrixFreeTest<dim, fe_degree, Number>::operator()(
+ const MatrixFree<dim, Number> &data,
+ std::vector<Vector<Number>> & dst,
+ const std::vector<Vector<Number>> &,
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval0(data, 0, 0);
FEEvaluation<dim, fe_degree + 1, fe_degree + 2, 1, Number> fe_eval1(data,
template <int dim, int fe_degree, typename Number>
void
-MatrixFreeTest<dim, fe_degree, Number>::
-operator()(const MatrixFree<dim, Number> &data,
- std::vector<Vector<Number>> & dst,
- const std::vector<Vector<Number>> &,
- const std::pair<unsigned int, unsigned int> &cell_range) const
+MatrixFreeTest<dim, fe_degree, Number>::operator()(
+ const MatrixFree<dim, Number> &data,
+ std::vector<Vector<Number>> & dst,
+ const std::vector<Vector<Number>> &,
+ const std::pair<unsigned int, unsigned int> &cell_range) const
{
FEEvaluation<dim, 0, 1, 1, Number> fe_eval0(data, 0, 0);
FEEvaluation<dim, fe_degree, fe_degree + 1, 1, Number> fe_eval1(data, 1, 1);
-void generate_grid(Triangulation<3> &triangulation, int orientation)
+void
+generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
Point<3>(+1., -1., -3.),
phif.inverse_jacobian(0))[dim - 1]) *
(number)(std::max(1, fe_degree) * (fe_degree + 1.0)) * 2.;
std::array<types::boundary_id, VectorizedArray<number>::size()>
- boundary_ids = data.get_faces_by_cells_boundary_id(cell, face);
+ boundary_ids = data.get_faces_by_cells_boundary_id(cell, face);
VectorizedArray<number> factor_boundary;
for (unsigned int v = 0; v < VectorizedArray<number>::size(); ++v)
// interior face
MyLaplaceOperator<dim, fe_degree, double> fine_matrix;
std::shared_ptr<MatrixFree<dim, double>> fine_level_data(
- new MatrixFree<dim, double>());
+ new MatrixFree<dim, double>());
typename MatrixFree<dim, double>::AdditionalData fine_level_additional_data;
fine_level_additional_data.tasks_parallel_scheme =
-void generate_grid(Triangulation<3> &triangulation, int orientation)
+void
+generate_grid(Triangulation<3> &triangulation, int orientation)
{
Point<3> vertices_1[] = {Point<3>(-0., -0., -0.),
Point<3>(+1., -0., -0.),
std::vector<double> solution_values(fe.dofs_per_cell);
std::vector<Vector<double>> function_values(unit_points.size(),
- Vector<double>(dim + 1));
+ Vector<double>(dim + 1));
std::vector<std::vector<Tensor<1, dim>>> function_gradients(
unit_points.size(), std::vector<Tensor<1, dim>>(dim + 1));
// Create 2d grid
-void create_grid(Triangulation<2> &tria)
+void
+create_grid(Triangulation<2> &tria)
{
GridGenerator::hyper_cube(tria);
// Create 3d grid
-void create_grid(Triangulation<3> &tria)
+void
+create_grid(Triangulation<3> &tria)
{
GridGenerator::hyper_cube<3>(tria);
tria.begin_active()->set_refine_flag(dealii::RefinementCase<3>::cut_x);
// ----- transfer -----
parallel::distributed::
CellDataTransfer<dim, spacedim, std::vector<std::vector<int>>>
- cell_data_transfer(
- tria,
- /*transfer_variable_size_data=*/true,
- /*refinement_strategy=*/
- &dealii::AdaptationStrategies::Refinement::
- preserve<dim, spacedim, std::vector<int>>,
- /*coarsening_strategy=*/&get_data_of_first_child<dim, spacedim>);
+ cell_data_transfer(
+ tria,
+ /*transfer_variable_size_data=*/true,
+ /*refinement_strategy=*/
+ &dealii::AdaptationStrategies::Refinement::
+ preserve<dim, spacedim, std::vector<int>>,
+ /*coarsening_strategy=*/&get_data_of_first_child<dim, spacedim>);
cell_data_transfer.prepare_for_coarsening_and_refinement(cell_data);
tria.execute_coarsening_and_refinement();
// ----- execute adaptation -----
parallel::distributed::CellDataTransfer<dim, dim, Vector<float>>
- data_transfer(tria,
- /*transfer_variable_size_data=*/false,
- &AdaptationStrategies::Refinement::l2_norm<dim, dim, float>,
- &AdaptationStrategies::Coarsening::l2_norm<dim, dim, float>);
+ data_transfer(tria,
+ /*transfer_variable_size_data=*/false,
+ &AdaptationStrategies::Refinement::l2_norm<dim, dim, float>,
+ &AdaptationStrategies::Coarsening::l2_norm<dim, dim, float>);
data_transfer.prepare_for_coarsening_and_refinement(predicted_errors);
tria.execute_coarsening_and_refinement();
// ----- execute adaptation -----
parallel::distributed::CellDataTransfer<dim, dim, Vector<float>>
- data_transfer(tria,
- /*transfer_variable_size_data=*/false,
- &AdaptationStrategies::Refinement::l2_norm<dim, dim, float>,
- &AdaptationStrategies::Coarsening::l2_norm<dim, dim, float>);
+ data_transfer(tria,
+ /*transfer_variable_size_data=*/false,
+ &AdaptationStrategies::Refinement::l2_norm<dim, dim, float>,
+ &AdaptationStrategies::Coarsening::l2_norm<dim, dim, float>);
data_transfer.prepare_for_coarsening_and_refinement(predicted_errors);
tria.execute_coarsening_and_refinement();
{
std::ofstream f("ordering",
(myid > 0) ? std::ofstream::app :
- std::ofstream::out);
+ std::ofstream::out);
std::vector<types::global_dof_index> local_dof_indices(
fe.dofs_per_cell);
for (typename DoFHandler<dim>::active_cell_iterator cell =
local_relevant.add_indices(&ghost_indices[0], &ghost_indices[0] + 10);
types::global_dof_index before_start = myid > 0 ? my_start - set / 4 : 0;
types::global_dof_index after_end = myid < numproc - 1 ?
- my_start + local_size + set / 3 :
- my_start + local_size;
+ my_start + local_size + set / 3 :
+ my_start + local_size;
if (before_start < my_start)
local_relevant.add_range(before_start, my_start);
if (after_end > my_start + local_size)
}
/* The 2D case */
-void generate_grid(parallel::distributed::Triangulation<2> &triangulation,
- int orientation)
+void
+generate_grid(parallel::distributed::Triangulation<2> &triangulation,
+ int orientation)
{
Point<2> vertices_1[] = {
Point<2>(-1., -3.),
/* The 3D case */
-void generate_grid(parallel::distributed::Triangulation<3> &triangulation,
- int orientation)
+void
+generate_grid(parallel::distributed::Triangulation<3> &triangulation,
+ int orientation)
{
Point<3> vertices_1[] = {Point<3>(-1., -1., -3.),
Point<3>(+1., -1., -3.),
local_dof_indices[j]) // ( boundary(i) && boundary(j)
// && i==j )
))
- {
- }
+ {}
else
{
cell_matrix(i, j) = 0;
local_dof_indices[j]) // ( boundary(i) && boundary(j)
// && i==j )
))
- {
- }
+ {}
else
{
cell_matrix(i, j) = 0;
local_dof_indices[j]) // ( boundary(i) && boundary(j)
// && i==j )
))
- {
- }
+ {}
else
{
cell_matrix(i, j) = 0;
local_dof_indices[j]) // ( boundary(i) && boundary(j) &&
// i==j )
))
- {
- }
+ {}
else
{
cell_matrix(i, j) = 0;
local_dof_indices[j]) // ( boundary(i) && boundary(j)
// && i==j )
))
- {
- }
+ {}
else
{
cell_matrix(i, j) = 0;
const unsigned int chunk_size = 8)
{
// forward to the other function
- run(begin,
- end,
- [&main_object, worker](const Iterator &iterator,
- ScratchData & scratch_data,
- CopyData & copy_data) {
- (main_object.*worker)(iterator, scratch_data, copy_data);
- },
- [&main_object, copier](const CopyData ©_data) {
- (main_object.*copier)(copy_data);
- },
- sample_scratch_data,
- sample_copy_data,
- queue_length,
- chunk_size);
+ run(
+ begin,
+ end,
+ [&main_object, worker](const Iterator &iterator,
+ ScratchData & scratch_data,
+ CopyData & copy_data) {
+ (main_object.*worker)(iterator, scratch_data, copy_data);
+ },
+ [&main_object, copier](const CopyData ©_data) {
+ (main_object.*copier)(copy_data);
+ },
+ sample_scratch_data,
+ sample_copy_data,
+ queue_length,
+ chunk_size);
}
} // namespace taskflow_v1
static X<0> x;
return x;
}
- X<0> foo_ref_1(X<1> &)
+ X<0>
+ foo_ref_1(X<1> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> static_foo_ref_1(X<1> &)
+ static X<0>
+ static_foo_ref_1(X<1> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_1(X<1> &)
+ X<0> &
+ ref_foo_ref_1(X<1> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_1(X<1> &)
+ const X<0> &
+ const_ref_foo_ref_1(X<1> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_1(X<1> &)
+ const X<0> &
+ const_ref_foo_const_ref_1(X<1> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_1_const(X<1> &) const
+ const X<0> &
+ const_ref_foo_ref_1_const(X<1> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_1_const(X<1> &) const
+ const X<0> &
+ const_ref_foo_const_ref_1_const(X<1> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_ref_1(X<1> &)
+ virtual const X<0> &
+ virtual_const_ref_foo_ref_1(X<1> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_1(X<1> &)
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_1(X<1> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_ref_1_const(X<1> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_ref_1_const(X<1> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_1_const(X<1> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_1_const(X<1> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> &static_ref_foo_ref_1(X<1> &)
+ static X<0> &
+ static_ref_foo_ref_1(X<1> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static const X<0> &static_const_ref_foo_ref_1(X<1> &)
+ static const X<0> &
+ static_const_ref_foo_ref_1(X<1> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_1_const(X<1> &) const
+ X<0>
+ foo_ref_1_const(X<1> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_1_const(X<1> &) const
+ X<0> &
+ ref_foo_ref_1_const(X<1> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_1_const(X<1> &) const
+ virtual X<0>
+ virtual_foo_ref_1_const(X<1> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_1_const(X<1> &) const
+ virtual X<0> &
+ virtual_ref_foo_ref_1_const(X<1> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_1(X<1> &)
+ virtual X<0>
+ virtual_foo_ref_1(X<1> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_1(X<1> &)
+ virtual X<0> &
+ virtual_ref_foo_ref_1(X<1> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_2(X<1> &, X<2> &)
+ X<0>
+ foo_ref_2(X<1> &, X<2> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> static_foo_ref_2(X<1> &, X<2> &)
+ static X<0>
+ static_foo_ref_2(X<1> &, X<2> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_2(X<1> &, X<2> &)
+ X<0> &
+ ref_foo_ref_2(X<1> &, X<2> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_2(X<1> &, X<2> &)
+ const X<0> &
+ const_ref_foo_ref_2(X<1> &, X<2> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_2(X<1> &, X<2> &)
+ const X<0> &
+ const_ref_foo_const_ref_2(X<1> &, X<2> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_2_const(X<1> &, X<2> &) const
+ const X<0> &
+ const_ref_foo_ref_2_const(X<1> &, X<2> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_2_const(X<1> &, X<2> &) const
+ const X<0> &
+ const_ref_foo_const_ref_2_const(X<1> &, X<2> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_ref_2(X<1> &, X<2> &)
+ virtual const X<0> &
+ virtual_const_ref_foo_ref_2(X<1> &, X<2> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_2(X<1> &, X<2> &)
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_2(X<1> &, X<2> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_ref_2_const(X<1> &, X<2> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_ref_2_const(X<1> &, X<2> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_2_const(X<1> &,
- X<2> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_2_const(X<1> &, X<2> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> &static_ref_foo_ref_2(X<1> &, X<2> &)
+ static X<0> &
+ static_ref_foo_ref_2(X<1> &, X<2> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static const X<0> &static_const_ref_foo_ref_2(X<1> &, X<2> &)
+ static const X<0> &
+ static_const_ref_foo_ref_2(X<1> &, X<2> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_2_const(X<1> &, X<2> &) const
+ X<0>
+ foo_ref_2_const(X<1> &, X<2> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_2_const(X<1> &, X<2> &) const
+ X<0> &
+ ref_foo_ref_2_const(X<1> &, X<2> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_2_const(X<1> &, X<2> &) const
+ virtual X<0>
+ virtual_foo_ref_2_const(X<1> &, X<2> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_2_const(X<1> &, X<2> &) const
+ virtual X<0> &
+ virtual_ref_foo_ref_2_const(X<1> &, X<2> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_2(X<1> &, X<2> &)
+ virtual X<0>
+ virtual_foo_ref_2(X<1> &, X<2> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_2(X<1> &, X<2> &)
+ virtual X<0> &
+ virtual_ref_foo_ref_2(X<1> &, X<2> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_3(X<1> &, X<2> &, X<3> &)
+ X<0>
+ foo_ref_3(X<1> &, X<2> &, X<3> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> static_foo_ref_3(X<1> &, X<2> &, X<3> &)
+ static X<0>
+ static_foo_ref_3(X<1> &, X<2> &, X<3> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
+ X<0> &
+ ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
+ const X<0> &
+ const_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_3(X<1> &, X<2> &, X<3> &)
+ const X<0> &
+ const_ref_foo_const_ref_3(X<1> &, X<2> &, X<3> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
+ const X<0> &
+ const_ref_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_3_const(X<1> &, X<2> &, X<3> &) const
+ const X<0> &
+ const_ref_foo_const_ref_3_const(X<1> &, X<2> &, X<3> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
+ virtual const X<0> &
+ virtual_const_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_3(X<1> &, X<2> &, X<3> &)
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_3(X<1> &, X<2> &, X<3> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual const X<0> &
- virtual_const_ref_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
+ virtual_const_ref_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual const X<0> &
- virtual_const_ref_foo_const_ref_3_const(X<1> &, X<2> &, X<3> &) const
+ virtual_const_ref_foo_const_ref_3_const(X<1> &, X<2> &, X<3> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> &static_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
+ static X<0> &
+ static_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static const X<0> &static_const_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
+ static const X<0> &
+ static_const_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
+ X<0>
+ foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
+ X<0> &
+ ref_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
+ virtual X<0>
+ virtual_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
+ virtual X<0> &
+ virtual_ref_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_3(X<1> &, X<2> &, X<3> &)
+ virtual X<0>
+ virtual_foo_ref_3(X<1> &, X<2> &, X<3> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
+ virtual X<0> &
+ virtual_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
+ X<0>
+ foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> static_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
+ static X<0>
+ static_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
+ X<0> &
+ ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
+ const X<0> &
+ const_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
+ const X<0> &
+ const_ref_foo_const_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
+ const X<0> &
+ const_ref_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
const X<0> &
- const_ref_foo_const_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
+ const_ref_foo_const_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual const X<0> &
- virtual_const_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
+ virtual_const_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual const X<0> &
- virtual_const_ref_foo_const_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
+ virtual_const_ref_foo_const_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual const X<0> &
- virtual_const_ref_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
+ virtual_const_ref_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_4_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> &static_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
+ static X<0> &
+ static_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static const X<0> &static_const_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
+ static const X<0> &
+ static_const_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
+ X<0>
+ foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
+ X<0> &
+ ref_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
+ virtual X<0>
+ virtual_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual X<0> &
- virtual_ref_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
+ virtual_ref_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
+ virtual X<0>
+ virtual_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
+ virtual X<0> &
+ virtual_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
+ X<0>
+ foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> static_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
+ static X<0>
+ static_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
+ X<0> &
+ ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
+ const X<0> &
+ const_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
+ const X<0> &
+ const_ref_foo_const_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
const X<0> &
- const_ref_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
+ const_ref_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_5_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &) const
+ const X<0> &
+ const_ref_foo_const_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual const X<0> &
- virtual_const_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
+ virtual_const_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual const X<0> &
- virtual_const_ref_foo_const_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
+ virtual_const_ref_foo_const_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_ref_5_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
+ const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_5_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_5_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> &static_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
+ static X<0> &
+ static_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
static const X<0> &
- static_const_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
+ static_const_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
+ X<0>
+ foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
+ X<0> &
+ ref_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual X<0>
- virtual_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
+ virtual_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual X<0> &
- virtual_ref_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
+ virtual_ref_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
+ virtual X<0>
+ virtual_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
+ virtual X<0> &
+ virtual_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
+ X<0>
+ foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> static_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
+ static X<0>
+ static_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
+ X<0> &
+ ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
const X<0> &
- const_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
+ const_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
const X<0> &
- const_ref_foo_const_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
+ const_ref_foo_const_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_6_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &) const
+ const X<0> &
+ const_ref_foo_ref_6_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
+ const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_6_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &) const
+ const X<0> &
+ const_ref_foo_const_ref_6_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual const X<0> &
- virtual_const_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
+ virtual_const_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_6(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &)
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_6(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_ref_6_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_ref_6_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_6_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_6_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
static X<0> &
- static_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
+ static_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
static const X<0> &
- static_const_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
+ static_const_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_6_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &) const
+ X<0>
+ foo_ref_6_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
X<0> &
- ref_foo_ref_6_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &) const
+ ref_foo_ref_6_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_6_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &) const
+ virtual X<0>
+ virtual_foo_ref_6_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_6_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &) const
+ virtual X<0> &
+ virtual_ref_foo_ref_6_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
+ const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
+ virtual X<0>
+ virtual_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual X<0> &
- virtual_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
+ virtual_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
+ X<0>
+ foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
static X<0>
- static_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
+ static_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
+ X<0> &
+ ref_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
const X<0> &
- const_ref_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
+ const_ref_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_7(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &)
+ const X<0> &
+ const_ref_foo_const_ref_7(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_7_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &) const
+ const X<0> &
+ const_ref_foo_ref_7_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_7_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &) const
+ const X<0> &
+ const_ref_foo_const_ref_7_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_ref_7(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &)
+ virtual const X<0> &
+ virtual_const_ref_foo_ref_7(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_7(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &)
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_7(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_ref_7_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_ref_7_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_7_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_7_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
static X<0> &
- static_ref_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
+ static_ref_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static const X<0> &static_const_ref_foo_ref_7(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &)
+ static const X<0> &
+ static_const_ref_foo_ref_7(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_7_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
- const
+ X<0>
+ foo_ref_7_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_7_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &) const
+ X<0> &
+ ref_foo_ref_7_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
+ const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_7_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &) const
+ virtual X<0>
+ virtual_foo_ref_7_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_7_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &) const
+ virtual X<0> &
+ virtual_ref_foo_ref_7_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
virtual X<0>
- virtual_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
+ virtual_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_7(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &)
+ virtual X<0> &
+ virtual_ref_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_8(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &, X<8> &)
+ X<0>
+ foo_ref_8(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &, X<8> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> static_foo_ref_8(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &)
+ static X<0>
+ static_foo_ref_8(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_8(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &)
+ X<0> &
+ ref_foo_ref_8(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &, X<8> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_8(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &)
+ const X<0> &
+ const_ref_foo_ref_8(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_8(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &)
+ const X<0> &
+ const_ref_foo_const_ref_8(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_ref_8_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &) const
+ const X<0> &
+ const_ref_foo_ref_8_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- const X<0> &const_ref_foo_const_ref_8_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &) const
+ const X<0> &
+ const_ref_foo_const_ref_8_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_ref_8(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &)
+ virtual const X<0> &
+ virtual_const_ref_foo_ref_8(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_8(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &)
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_8(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_ref_8_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_ref_8_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual const X<0> &virtual_const_ref_foo_const_ref_8_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &) const
+ virtual const X<0> &
+ virtual_const_ref_foo_const_ref_8_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static X<0> &static_ref_foo_ref_8(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &)
+ static X<0> &
+ static_ref_foo_ref_8(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- static const X<0> &static_const_ref_foo_ref_8(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &)
+ static const X<0> &
+ static_const_ref_foo_ref_8(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- X<0> foo_ref_8_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &) const
+ X<0>
+ foo_ref_8_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- X<0> &ref_foo_ref_8_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &) const
+ X<0> &
+ ref_foo_ref_8_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_8_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &) const
+ virtual X<0>
+ virtual_foo_ref_8_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_8_const(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &) const
+ virtual X<0> &
+ virtual_ref_foo_ref_8_const(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &) const
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
static X<0> x;
return x;
}
- virtual X<0> virtual_foo_ref_8(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &)
+ virtual X<0>
+ virtual_foo_ref_8(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
return x;
}
- virtual X<0> &virtual_ref_foo_ref_8(X<1> &,
- X<2> &,
- X<3> &,
- X<4> &,
- X<5> &,
- X<6> &,
- X<7> &,
- X<8> &)
+ virtual X<0> &
+ virtual_ref_foo_ref_8(X<1> &,
+ X<2> &,
+ X<3> &,
+ X<4> &,
+ X<5> &,
+ X<6> &,
+ X<7> &,
+ X<8> &)
{
deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
static X<0> x;
#include "../tests.h"
-void colorize_sixty_deg_hyper_shell(Triangulation<3> &tria,
- const Point<3> & center,
- const double inner_radius,
- const double outer_radius)
+void
+colorize_sixty_deg_hyper_shell(Triangulation<3> &tria,
+ const Point<3> & center,
+ const double inner_radius,
+ const double outer_radius)
{
// if (tria.n_cells() != 4)
// AssertThrow (false, ExcNotImplemented());
}
}
-void sixty_deg_hyper_shell(Triangulation<3> &tria,
- const Point<3> & center,
- const double inner_radius,
- const double outer_radius)
+void
+sixty_deg_hyper_shell(Triangulation<3> &tria,
+ const Point<3> & center,
+ const double inner_radius,
+ const double outer_radius)
{
const double r0 = inner_radius;
const double r1 = outer_radius;
}
-void do_rotate(Triangulation<1> &)
+void
+do_rotate(Triangulation<1> &)
{}
}
-void do_rotate(Triangulation<1> &)
+void
+do_rotate(Triangulation<1> &)
{}
-void resize(Table<2, double> &coeff, const unsigned int N)
+void
+resize(Table<2, double> &coeff, const unsigned int N)
{
coeff.reinit(N, N);
}
-void resize(Table<3, double> &coeff, const unsigned int N)
+void
+resize(Table<3, double> &coeff, const unsigned int N)
{
TableIndices<3> size;
for (unsigned int d = 0; d < 3; d++)
template <typename CoefficientType>
void
- prepare_symmetric_coefficients(Table<1, CoefficientType> & coeff,
- const std::vector<CoefficientType> &coeff_1d)
+prepare_symmetric_coefficients(Table<1, CoefficientType> & coeff,
+ const std::vector<CoefficientType> &coeff_1d)
{
Assert(coeff.size(0) == coeff_1d.size(), ExcInternalError());
template <typename CoefficientType>
void
- prepare_symmetric_coefficients(Table<2, CoefficientType> & coeff,
- const std::vector<CoefficientType> &coeff_1d)
+prepare_symmetric_coefficients(Table<2, CoefficientType> & coeff,
+ const std::vector<CoefficientType> &coeff_1d)
{
for (unsigned int d = 0; d < 2; ++d)
Assert(coeff.size(d) == coeff_1d.size(), ExcInternalError());
template <typename CoefficientType>
void
- prepare_symmetric_coefficients(Table<3, CoefficientType> & coeff,
- const std::vector<CoefficientType> &coeff_1d)
+prepare_symmetric_coefficients(Table<3, CoefficientType> & coeff,
+ const std::vector<CoefficientType> &coeff_1d)
{
for (unsigned int d = 0; d < 3; ++d)
Assert(coeff.size(d) == coeff_1d.size(), ExcInternalError());
counter++;
if ((counter == 4) || (counter == 5) || (counter == 6) ||
(counter == 18) || (counter == 19))
- {
- }
+ {}
else
out << line << std::endl;
}
counter++;
if ((counter == 4) || (counter == 5) || (counter == 6) ||
(counter == 18) || (counter == 19))
- {
- }
+ {}
else
out << line << std::endl;
}
&ls_minimization_function_ptrb,
&use_ptrb]() {
const auto res_0 = (use_ptrb ? ls_minimization_function_ptrb(0.0) :
- ls_minimization_function(0.0));
+ ls_minimization_function(0.0));
Assert(res_0.second < 0.0,
ExcMessage("Gradient should be negative. Current value: " +
std::to_string(res_0.second)));
const auto res_1 = (use_ptrb ? ls_minimization_function_ptrb(1.0) :
- ls_minimization_function(1.0));
+ ls_minimization_function(1.0));
// Wriggers discussion after 5.14
if (res_0.second * res_1.second > 0.0)
a_max,
max_evals,
debug_linesearch) :
- LineMinimization::line_search<double>(
+ LineMinimization::line_search<double>(
ls_minimization_function,
res_0.first,
res_0.second,
using namespace dealii::Physics;
template <int dim, typename Number>
-void initialize(Tensor<1, dim, Number> &x)
+void
+initialize(Tensor<1, dim, Number> &x)
{
for (unsigned int i = 0; i < x.n_independent_components; ++i)
x[i] = i + 1;
}
template <int dim, typename Number>
-void initialize(Tensor<2, dim, Number> &x)
+void
+initialize(Tensor<2, dim, Number> &x)
{
unsigned int c = 1;
for (unsigned int i = 0; i < dim; ++i)
}
template <int dim, typename Number>
-void initialize(SymmetricTensor<2, dim, Number> &x)
+void
+initialize(SymmetricTensor<2, dim, Number> &x)
{
unsigned int c = 1;
for (unsigned int i = 0; i < dim; ++i)
}
template <int dim, typename Number>
-void initialize(Tensor<3, dim, Number> &x)
+void
+initialize(Tensor<3, dim, Number> &x)
{
unsigned int c = 1;
for (unsigned int i = 0; i < dim; ++i)
// A specialised constructor mimicking the construction
// of a rank-3 tensor with two symmetric components
template <int dim, typename Number>
-void initialize(Tensor<3, dim, Number> &x,
- const bool left_components_are_symmetric)
+void
+initialize(Tensor<3, dim, Number> &x, const bool left_components_are_symmetric)
{
Tensor<1, dim, Number> v;
initialize(v);
}
template <int dim, typename Number>
-void initialize(Tensor<4, dim, Number> &x)
+void
+initialize(Tensor<4, dim, Number> &x)
{
unsigned int c = 1;
for (unsigned int i = 0; i < dim; ++i)
}
template <int dim, typename Number>
-void initialize(SymmetricTensor<4, dim, Number> &x)
+void
+initialize(SymmetricTensor<4, dim, Number> &x)
{
unsigned int c = 1;
for (unsigned int i = 0; i < dim; ++i)
using namespace dealii::Physics;
template <int dim, typename Number>
-void initialize(Tensor<1, dim, Number> &x)
+void
+initialize(Tensor<1, dim, Number> &x)
{
for (unsigned int i = 0; i < x.n_independent_components; ++i)
x[i] = i + 1;
}
template <int dim, typename Number>
-void initialize(Tensor<2, dim, Number> &x)
+void
+initialize(Tensor<2, dim, Number> &x)
{
unsigned int c = 1;
for (unsigned int i = 0; i < dim; ++i)
}
template <int dim, typename Number>
-void initialize(SymmetricTensor<2, dim, Number> &x)
+void
+initialize(SymmetricTensor<2, dim, Number> &x)
{
unsigned int c = 1;
for (unsigned int i = 0; i < dim; ++i)
}
template <int dim, typename Number>
-void initialize(Tensor<3, dim, Number> &x)
+void
+initialize(Tensor<3, dim, Number> &x)
{
unsigned int c = 1;
for (unsigned int i = 0; i < dim; ++i)
// A specialised constructor mimicking the construction
// of a rank-3 tensor with two symmetric components
template <int dim, typename Number>
-void initialize(Tensor<3, dim, Number> &x,
- const bool left_components_are_symmetric)
+void
+initialize(Tensor<3, dim, Number> &x, const bool left_components_are_symmetric)
{
Tensor<1, dim, Number> v;
initialize(v);
}
template <int dim, typename Number>
-void initialize(Tensor<4, dim, Number> &x)
+void
+initialize(Tensor<4, dim, Number> &x)
{
unsigned int c = 1;
for (unsigned int i = 0; i < dim; ++i)
}
template <int dim, typename Number>
-void initialize(SymmetricTensor<4, dim, Number> &x)
+void
+initialize(SymmetricTensor<4, dim, Number> &x)
{
unsigned int c = 1;
for (unsigned int i = 0; i < dim; ++i)
using namespace dealii::Physics;
template <int dim, typename Number>
-void initialize(Tensor<0, dim, Number> &x)
+void
+initialize(Tensor<0, dim, Number> &x)
{
x = 1.0;
}
template <int dim, typename Number>
-void initialize(Tensor<1, dim, Number> &x)
+void
+initialize(Tensor<1, dim, Number> &x)
{
for (unsigned int i = 0; i < x.n_independent_components; ++i)
x[i] = 1.0;
}
template <int dim, typename Number>
-void initialize(Tensor<2, dim, Number> &x)
+void
+initialize(Tensor<2, dim, Number> &x)
{
for (unsigned int i = 0; i < dim; ++i)
for (unsigned int j = 0; j < dim; ++j)
}
template <int dim, typename Number>
-void initialize(SymmetricTensor<2, dim, Number> &x)
+void
+initialize(SymmetricTensor<2, dim, Number> &x)
{
for (unsigned int i = 0; i < dim; ++i)
for (unsigned int j = i; j < dim; ++j)
}
template <int dim, typename Number>
-void initialize(Tensor<3, dim, Number> &x)
+void
+initialize(Tensor<3, dim, Number> &x)
{
for (unsigned int i = 0; i < dim; ++i)
for (unsigned int j = 0; j < dim; ++j)
}
template <int dim, typename Number>
-void initialize(Tensor<4, dim, Number> &x)
+void
+initialize(Tensor<4, dim, Number> &x)
{
for (unsigned int i = 0; i < dim; ++i)
for (unsigned int j = 0; j < dim; ++j)
}
template <int dim, typename Number>
-void initialize(SymmetricTensor<4, dim, Number> &x)
+void
+initialize(SymmetricTensor<4, dim, Number> &x)
{
for (unsigned int i = 0; i < dim; ++i)
for (unsigned int j = i; j < dim; ++j)
std::vector<types::global_dof_index> local_dof_indices(dofs_per_cell);
BodyForce<dim> body_force;
std::vector<Vector<double>> body_force_values(n_q_points,
- Vector<double>(dim));
+ Vector<double>(dim));
typename DoFHandler<dim>::active_cell_iterator cell =
dof_handler.begin_active(),
endc = dof_handler.end();
std::vector<types::global_dof_index> local_dof_indices(dofs_per_cell);
BodyForce<dim> body_force;
std::vector<Vector<double>> body_force_values(n_q_points,
- Vector<double>(dim));
+ Vector<double>(dim));
typename DoFHandler<dim>::active_cell_iterator cell =
dof_handler.begin_active(),
endc = dof_handler.end();
for (unsigned int i = 0; i < v.size(); ++i)
v[i] = i + 1;
int result = 0;
- WorkStream::run(v.begin(),
- v.end(),
- &assemble,
- [&result](const copy_data &data) { copy(result, data); },
- scratch_data(),
- copy_data());
+ WorkStream::run(
+ v.begin(),
+ v.end(),
+ &assemble,
+ [&result](const copy_data &data) { copy(result, data); },
+ scratch_data(),
+ copy_data());
std::cout << "result: " << result << std::endl;
if (result != maxi * (maxi + 1) / 2)
template <int spacedim>
-void do_boundary(Triangulation<1, spacedim> &)
+void
+do_boundary(Triangulation<1, spacedim> &)
{}
template <int spacedim>
-void do_boundary(Triangulation<1, spacedim> &)
+void
+do_boundary(Triangulation<1, spacedim> &)
{}
template <int spacedim>
-void do_boundary(Triangulation<1, spacedim> &)
+void
+do_boundary(Triangulation<1, spacedim> &)
{}
template <int spacedim>
-void do_boundary(Triangulation<1, spacedim> &)
+void
+do_boundary(Triangulation<1, spacedim> &)
{}
using namespace dealii;
-void make_grid(Triangulation<2> &triangulation)
+void
+make_grid(Triangulation<2> &triangulation)
{
Triangulation<2> triangulation_temp;
using namespace dealii;
-void make_grid(Triangulation<2> &triangulation)
+void
+make_grid(Triangulation<2> &triangulation)
{
Triangulation<2> triangulation_temp;
triangulation.refine_global(); // WARNING: no local refinement is performed
}
-void distribute_dofs(DoFHandler<2> &dof_handler)
+void
+distribute_dofs(DoFHandler<2> &dof_handler)
{
const FE_SimplexP<2> finite_element(1);
dof_handler.distribute_dofs(finite_element);
sparsity_pattern.print_svg(deallog.get_file_stream());
}
-void renumber_dofs(DoFHandler<2> &dof_handler)
+void
+renumber_dofs(DoFHandler<2> &dof_handler)
{
DoFRenumbering::Cuthill_McKee(dof_handler);
const LinearSolvers::BlockSchurPreconditioner<
TrilinosWrappers::PreconditionAMG,
TrilinosWrappers::PreconditionIC>
- preconditioner(stokes_matrix, mp_inverse, *Amg_preconditioner);
+ preconditioner(stokes_matrix, mp_inverse, *Amg_preconditioner);
SolverControl solver_control(stokes_matrix.m(),
1e-6 * stokes_rhs.l2_norm());
SolverGMRES<TrilinosWrappers::MPI::BlockVector> gmres(
template <typename number_t,
enum SD::OptimizerType opt_method,
enum SD::OptimizationFlags opt_flags,
- template <typename> class FunctionStruct>
+ template <typename>
+ class FunctionStruct>
void
test_functions()
{
template <int dim>
-void initialize(SymmetricTensor<2, dim> &st)
+void
+initialize(SymmetricTensor<2, dim> &st)
{
for (unsigned int i = 0; i < dim; ++i)
for (unsigned int j = i; j < dim; ++j)
template <int dim>
-void initialize(SymmetricTensor<4, dim> &st)
+void
+initialize(SymmetricTensor<4, dim> &st)
{
for (unsigned int i = 0; i < dim; ++i)
for (unsigned int j = i; j < dim; ++j)
// from NumberType2
template <int rank,
int dim,
- template <int, int, typename> class TensorType,
+ template <int, int, typename>
+ class TensorType,
typename NumberType1,
typename NumberType2>
typename std::enable_if<!std::is_constructible<NumberType1, NumberType2>::value,
template <int rank,
int dim,
- template <int, int, typename> class TensorType,
+ template <int, int, typename>
+ class TensorType,
typename NumberType1,
typename NumberType2>
typename std::enable_if<std::is_constructible<NumberType1, NumberType2>::value,
template <int rank,
int dim,
- template <int, int, typename> class TensorType,
+ template <int, int, typename>
+ class TensorType,
typename NumberType1>
void
test_fixed_NT_2(const std::string &type1)
int rank3,
int dim,
typename number,
- template <int, int, typename> class T1,
- template <int, int, typename> class T3>
+ template <int, int, typename>
+ class T1,
+ template <int, int, typename>
+ class T3>
void
test_symm_tensor_contract_3(const T1<rank1, dim, number> & l,
const Tensor<rank2, dim, number> &m,
// in clang-3.7.0 and clang-3.9.1 in release mode. Hence, use a separate
// function.
template <int dim, typename Number>
-void fill_tensor(
- dealii::SymmetricTensor<2, dim, dealii::VectorizedArray<Number>> &A)
+void
+fill_tensor(dealii::SymmetricTensor<2, dim, dealii::VectorizedArray<Number>> &A)
{
Number counter = 0.0;
for (unsigned int i = 0; i < dim; ++i)
}
template <int dim>
-bool check_orientation(Tensor<1, dim> v1, Tensor<1, dim> v2)
+bool
+check_orientation(Tensor<1, dim> v1, Tensor<1, dim> v2)
{
v1 /= v1.norm();
v2 /= v2.norm();
}
template <int dim>
-bool check_orientation(Tensor<1, dim> v1,
- Tensor<1, dim> v2,
- const double tol = 1e-9)
+bool
+check_orientation(Tensor<1, dim> v1, Tensor<1, dim> v2, const double tol = 1e-9)
{
v1 /= v1.norm();
v2 /= v2.norm();
}
template <int dim,
- template <int, int, typename> class TensorType1,
+ template <int, int, typename>
+ class TensorType1,
typename NumberType1,
- template <int, int, typename> class TensorType2,
+ template <int, int, typename>
+ class TensorType2,
typename NumberType2>
void
print(const TensorType1<2, dim, NumberType1> &t2,
}
template <int dim,
- template <int, int, typename> class TensorType1,
+ template <int, int, typename>
+ class TensorType1,
typename NumberType1,
- template <int, int, typename> class TensorType2,
+ template <int, int, typename>
+ class TensorType2,
typename NumberType2>
void
print(const TensorType1<2, dim, NumberType1> &t2_1,
template <template <int, int, typename> class TensorType1,
- template <int, int, typename> class TensorType2>
+ template <int, int, typename>
+ class TensorType2>
struct AreSame : std::false_type
{};
template <template <int, int, typename> class TensorType1,
typename NumberType1,
- template <int, int, typename> class TensorType2,
+ template <int, int, typename>
+ class TensorType2,
typename NumberType2>
void
test_one()
template <template <int, int, typename> class TensorType1,
typename NumberType1,
- template <int, int, typename> class TensorType2,
+ template <int, int, typename>
+ class TensorType2,
typename NumberType2>
typename std::enable_if<AreSame<TensorType1, TensorType2>::value>::type
test_two()
template <template <int, int, typename> class TensorType1,
typename NumberType1,
- template <int, int, typename> class TensorType2,
+ template <int, int, typename>
+ class TensorType2,
typename NumberType2>
typename std::enable_if<!AreSame<TensorType1, TensorType2>::value>::type
test_two()
template <template <int, int, typename> class TensorType1,
typename NumberType1,
- template <int, int, typename> class TensorType2,
+ template <int, int, typename>
+ class TensorType2,
typename NumberType2>
typename std::enable_if<(AreSame<TensorType1, SymmetricTensor>::value &&
AreSame<TensorType2, SymmetricTensor>::value)>::type
template <template <int, int, typename> class TensorType1,
typename NumberType1,
- template <int, int, typename> class TensorType2,
+ template <int, int, typename>
+ class TensorType2,
typename NumberType2>
typename std::enable_if<!(AreSame<TensorType1, SymmetricTensor>::value &&
AreSame<TensorType2, SymmetricTensor>::value)>::type
template <template <int, int, typename> class TensorType1,
typename NumberType1,
- template <int, int, typename> class TensorType2,
+ template <int, int, typename>
+ class TensorType2,
typename NumberType2>
void
test_all()
projects / dealii.git / commitdiff