}
-// As boundary values, we choose x*x+y*y in 2D, and x*x+y*y+z*z in 3D. This
+// As boundary values, we choose $x^2+y^2$ in 2D, and $x^2+y^2+z^2$ in 3D. This
// happens to be equal to the square of the vector from the origin to the
// point at which we would like to evaluate the function, irrespective of the
// dimension. So that is what we return:
* vector that will be part of this view.
* @param[in] size_of_view
*
- * @pre <code>starting_index + size_of_view <= vector.size()
+ * @pre <code>starting_index + size_of_view <= vector.size()</code>
*
* @relates ArrayView
*/
* vector that will be part of this view.
* @param[in] size_of_view
*
- * @pre <code>starting_index + size_of_view <= vector.size()
+ * @pre <code>starting_index + size_of_view <= vector.size()</code>
*
* @relates ArrayView
*/
* Note: the curl of a scalar function is given by $\text{curl}(f(x,y)) =
* \begin{pmatrix} f_{y}(x,y) \\ -f_{x}(x,y) \end{pmatrix}$.
*
- * <dd> The basis used to construct the $BDM_{1}$ shape functions is
+ * The basis used to construct the $BDM_{1}$ shape functions is
* @f{align*}
* \phi_0 = \begin{pmatrix} 1 \\ 0 \end{pmatrix},
* \phi_1 = \begin{pmatrix} -\sqrt{3}+2\sqrt{3}x \\ 0 \end{pmatrix},
* \phi_7 = \begin{pmatrix} 2xy \\ -y^2 \end{pmatrix}.
* @f}
*
- * <dd> The dimension of the $BDM_{k}$ space is
+ * The dimension of the $BDM_{k}$ space is
* $(k+1)(k+2)+2$, with $k+1$ unknowns per
* edge and $k(k-1)$ interior unknowns.
*
* \begin{pmatrix}0\\zx^{i+1}y^{k-i}\\0\end{pmatrix})
* , p_{k} \in (P_{k})^{3} \}$.
*
- * <dd> Note: the 3D description of $BDM_{k}$ is not unique.
- * See <i>Mixed and Hybrid Finite Element Methods</i> page 122
- * for an alternative definition.
+ * Note: the 3D description of $BDM_{k}$ is not unique. See <i>Mixed and
+ * Hybrid Finite Element Methods</i> page 122 for an alternative definition.
*
- * <dd> The dimension of the $BDM_{k}$ space is
- * $\dfrac{(k+1)(k+2)(k+3)}{2} + 3(k+1)$, with $\dfrac{(k+1)(k+2)}{2}$
- * unknowns per face and $\dfrac{(k-1)k(k+1)}{2}$ interior unknowns.
+ * The dimension of the $BDM_{k}$ space is
+ * $\dfrac{(k+1)(k+2)(k+3)}{2}+3(k+1)$, with $\dfrac{(k+1)(k+2)}{2}$
+ * unknowns per face and $\dfrac{(k-1)k(k+1)}{2}$ interior unknowns.
*
*</dl>
*
* weights before repartitioning occurs. Called from
* execute_coarsening_and_refinement() and repartition().
*
- * @param return A vector of unsigned integers representing the weight or
+ * @return A vector of unsigned integers representing the weight or
* computational load of every cell after the refinement/coarsening/
* repartition cycle. Note that the number of entries does not need to
* be equal to either n_active_cells or n_locally_owned_active_cells,
*
* where @f[ J^{\dagger} = J(\hat{\mathbf x})(J(\hat{\mathbf x})^{T} J(\hat{\mathbf x}))^{-1}.
* @f]
+ * </ul>
*
* Hessians of spacedim-vector valued differentiable functions are
* transformed this way (After subtraction of the product of the
* dim==2, then the cells are quadrilaterals that either live in the
* plane, or form a surface in a higher-dimensional space. The dimension
* of the cells of the surface mesh is consequently dim-1.
- * @param spacedim The dimension of the space in which both the volume and
+ * @tparam spacedim The dimension of the space in which both the volume and
* the surface mesh live.
*
* @param[in] volume_mesh A container of cells that define the volume mesh.
* above, this function only computes the threshold values and then passes
* over to refine() and coarsen().
*
- * @param[in,out] triangulation The triangulation whose cells this function is
+ * @param[in,out] tria The triangulation whose cells this function is
* supposed to mark for coarsening and refinement.
*
* @param[in] criteria The refinement criterion computed on each mesh cell.
* C++ standard library, this class implements an element of a vector space
* suitable for numerical computations.
*
- * @authod Bruno Turcksin, 2015.
+ * @author Bruno Turcksin, 2015.
*/
template <typename Number>
class Vector : public ReadWriteVector<Number>, public VectorSpaceVector<Number>
/**
* Similar to the function above, but for BlockDynamicSparsityPattern
* instead.
+ *
+ * @param[in,out] dsp The locally built sparsity pattern to be modified.
* @param owned_set_per_cpu Typically the value given by
* DoFHandler::locally_owned_dofs_per_processor.
*
+ * @param mpi_comm The MPI communicator to use.
+ *
* @param myrange Typically the locally relevant DoFs.
*/
void distribute_sparsity_pattern
* dim==3. However, their implementation is largly independent of the
* spacedim template parameter. So we would like to write things like
*
+ * @code
* template <int spacedim>
* void Triangulation<1,spacedim>::create_triangulation (...) {...}
+ * @endcode
*
* Unfortunately, C++ doesn't allow this: member functions of class
* templates have to be either not specialized at all, or fully
* solution would be to just duplicate the bodies of the functions and
* have equally implemented functions
*
+ * @code
* template <>
* void Triangulation<1,1>::create_triangulation (...) {...}
*
* template <>
* void Triangulation<1,2>::create_triangulation (...) {...}
+ * @endcode
*
* but that is clearly an unsatisfactory solution. Rather, what we do
* is introduce the current Implementation class in which we can write
* these functions as member templates over spacedim, i.e. we can have
*
+ * @code
* template <int dim_, int spacedim_>
* template <int spacedim>
* void Triangulation<dim_,spacedim_>::Implementation::
* create_triangulation (...,
* Triangulation<1,spacedim> &tria ) {...}
+ * @endcode
*
* The outer template parameters are here unused, only the inner
* ones are of real interest.
projects / dealii.git / commitdiff