* of the ArrayView is inferred from the value type of the iterator (e.g., the
* view created from two const iterators will have a const type).
*
- * @warning The iterators @begin and @p end must bound (in the usual half-open
+ * @warning The iterators @p begin and @p end must bound (in the usual half-open
* way) a contiguous in memory range of values. This function is intended for
* use with iterators into containers like
* <code>boost::container::small_vector</code> or <code>std::vector</code> and
* exception's message. These strings are represented as <code>const char
* *</code> pointers since the underlying buffer comes from (and is managed
* by) the run-time type information system: more exactly, these pointers are
- * the result the function call <code>typeid(x).name()<code> where
+ * the result the function call <code>typeid(x).name()</code> where
* <code>x</code> is some object. Therefore, the pointers provided to
* subscribe() and to unsubscribe() must be the same. Strings with equal
* contents will not be recognized to be the same. The handling in
/**
* Return a constant reference to the selected finite element object.
- * Since there is only one FiniteElement @index must be equal to zero
+ * Since there is only one FiniteElement @p index must be equal to zero
* which is also the default value.
*/
const FiniteElement<dim,spacedim> &
const bool invert_vertex_mapping = false);
/**
- * Same as above but allows boundary dofs on blocks to be excluded individually.
+ * Same as above but allows boundary dofs on blocks to be excluded individually.
*
- * This is helpful if you want to use, for example, Taylor Hood elements
- * as it allows you to not include the boundary DoFs for the velocity
- * block on the patches while also letting you include the boundary DoFs
- * for the pressure block.
+ * This is helpful if you want to use, for example, Taylor Hood elements as
+ * it allows you to not include the boundary DoFs for the velocity block on
+ * the patches while also letting you include the boundary DoFs for the
+ * pressure block.
*
- * @param exclude_boundary_dofs For each patch of cells around a
- * vertex, collect all of the interior degrees of freedom of the patch and
- * disregard those on the boundary of the patch if the boolean value for
- * the corresponding block in the BlockMask is false.
+ * For each patch of cells around a vertex, collect all of the interior
+ * degrees of freedom of the patch and disregard those on the boundary of
+ * the patch if the boolean value for the corresponding block in the
+ * BlockMask of @p exclude_boundary_dofs is false.
*/
template <typename DoFHandlerType>
std::vector<unsigned int>
* of the object. The barycenter for an object $K$
* of dimension $d$ in $D$ space dimensions is given by the $D$-dimensional
* vector $\mathbf x_K$ defined by
- * @f{
+ * @f[
* \mathbf x_K = \frac{1}{|K|} \int_K \mathbf x \; \textrm{d}x
- * @f}
+ * @f]
* where the measure of the object is given by
- * @f{
+ * @f[
* |K| = \int_K \mathbf 1 \; \textrm{d}x.
- * @f}
+ * @f]
* This function assumes that $K$ is mapped by a $d$-linear function from
* the reference $d$-dimensional cell. Then the integrals above can be
* pulled back to the reference cell and evaluated exactly (if through
struct SelectEvaluator<dim, -1, n_q_points_1d, n_components, Number>
{
/**
- * Based on the the run time parameters stored in @shape_info this function
+ * Based on the the run time parameters stored in @p shape_info this function
* chooses an appropriate evaluation strategy for the integrate function, i.e.
* this calls internal::FEEvaluationImpl::evaluate(),
* internal::FEEvaluationImplCollocation::evaluate() or
* field and separate vectors, ensuring thread safety. The mechanism to
* acquire and release objects is similar to the mechanisms used for the
* local contributions of WorkStream, see
- * @ref workstream_paper "the WorkStream paper"
- * .
+ * @ref workstream_paper "the WorkStream paper".
*/
AlignedVector<VectorizedArray<Number> > *acquire_scratch_data() const;
const LinearAlgebra::distributed::BlockVector<Number> &src) const;
/**
- * Transfer from a block-vector on the global grid to block-vectors defined on each of the levels separately.
+ * Transfer from a block-vector on the global grid to block-vectors defined
+ * on each of the levels separately.
*
- * This function will initialize @dst accordingly if needed as required by the Multigrid class.
+ * This function will initialize @p dst accordingly if needed as required by
+ * the Multigrid class.
*/
template <typename Number2, int spacedim>
void
* a given point, or
* searching the points that fall within a radius of a target point.
*
- * @quotation
- * From wikipedia (https://en.wikipedia.org/wiki/K-d_tree):
- *
- * A k-d tree is a binary tree in which every node is a $k$-dimensional point.
- * Every non-leaf node can be thought of as implicitly generating a splitting
- * hyperplane that divides the space into two parts, known as half-spaces.
- * Points to the left of this hyperplane are represented by the left subtree of
- * that node and points right of the hyperplane are represented by the right
- * subtree. The hyperplane direction is chosen in the following way: every node
- * in the tree is associated with one of the $k$-dimensions, with the hyperplane
- * perpendicular to that dimension's axis. So, for example, if for a particular
- * split the "x" axis is chosen, all points in the subtree with a smaller "x"
- * value than the node will appear in the left subtree and all points with
- * larger "x" value will be in the right subtree. In such a case, the
- * hyperplane would be set by the $x$-value of the point, and its normal would be
- * the unit $x$-axis.
- * @endquotation
+ * > From wikipedia (https://en.wikipedia.org/wiki/K-d_tree):
+ * >
+ * > A k-d tree is a binary tree in which every node is a $k$-dimensional point.
+ * > Every non-leaf node can be thought of as implicitly generating a splitting
+ * > hyperplane that divides the space into two parts, known as half-spaces.
+ * > Points to the left of this hyperplane are represented by the left subtree of
+ * > that node and points right of the hyperplane are represented by the right
+ * > subtree. The hyperplane direction is chosen in the following way: every node
+ * > in the tree is associated with one of the $k$-dimensions, with the hyperplane
+ * > perpendicular to that dimension's axis. So, for example, if for a particular
+ * > split the "x" axis is chosen, all points in the subtree with a smaller "x"
+ * > value than the node will appear in the left subtree and all points with
+ * > larger "x" value will be in the right subtree. In such a case, the
+ * > hyperplane would be set by the $x$-value of the point, and its normal would be
+ * > the unit $x$-axis.
*
* @author Luca Heltai, 2017.
*/
* that are at distance less than or equal to the given radius from
* the target point.
*
- * @param[in] point The target point
+ * @param[in] target The target point
* @param[in] radius The radius of the ball
- * @param[in] sorted Sort the output results in ascending order with respect to distances
+ * @param[in] sorted If @p true, sort the output results in ascending order with respect to distance
*
- * @return A vector of indices and distances of the matching points
+ * @return A vector of indices and distances to @p target of the matching points
*/
std::vector<std::pair<unsigned int, double> >
get_points_within_ball (const Point<dim> &target,
projects / dealii.git / commitdiff