// @sect4{LaplaceProblem::run}
- // Like several of the functions above, this is almost exactly a copy of of
+ // Like several of the functions above, this is almost exactly a copy of
// the corresponding function in step-6. The only difference is the call to
// <code>assemble_multigrid</code> that takes care of forming the matrices
// on every level that we need in the multigrid method.
// reduces the bandwidth of the matrix, or maybe more importantly: in such a
// way that the ILU is as close as possible to a real LU decomposition. On
// the other hand, we need to preserve the block structure of velocity and
- // pressure already seen in in step-20 and step-21. This is done in two
+ // pressure already seen in step-20 and step-21. This is done in two
// steps: First, all dofs are renumbered to improve the ILU and then we
// renumber once again by components. Since
// <code>DoFRenumbering::component_wise</code> does not touch the
=
\beta
\|\mathbf{u}\|_{L^\infty(K)} h_K
-$ to eliminate the effect of of the constant $c_R$ (we know that
+$ to eliminate the effect of the constant $c_R$ (we know that
solutions are stable by using this version of $\nu(T)$ as an artificial
viscosity, but that we can improve things -- i.e. make the solution
sharper -- by using the more complicated formula for this artificial
// @sect4{LaplaceProblem::run}
// Like several of the functions above, this
- // is almost exactly a copy of of the
+ // is almost exactly a copy of the
// corresponding function in step-6. The only
// difference is the call to
// <code>assemble_multigrid</code> that takes
normal projection is available, the point which is closest to the
shape---typically lying on the shape boundary---is selected. If the shape is
composed of several sub-shapes, the projection is carried out onto every
-single sub-shape, and the closest projection point point is selected.
+single sub-shape, and the closest projection point is selected.
<img src="https://www.dealii.org/images/steps/developer/step-54.NormalProjectionEdge.png" alt="" width="500">
<img src="https://www.dealii.org/images/steps/developer/step-54.NormalProjection.png" alt="" width="500">
&(size_all_data[0]), 1, MPI_INT,
comm);
- // Now computing the the displacement, relative to recvbuf,
+ // Now computing the displacement, relative to recvbuf,
// at which to store the incoming buffer
std::vector<int> rdispls(n_procs);
rdispls[0] = 0;
* [0,1]x[0,1], etc.
*
* There are a number of derived classes, denoting concrete integration
- * formulae. Their names names prefixed by <tt>Q</tt>. Refer to the list of
+ * formulae. Their names are prefixed by <tt>Q</tt>. Refer to the list of
* derived classes for more details.
*
* The schemes for higher dimensions are typically tensor products of the one-
/**
* Declare an array type which can be used to initialize an object of this
- * type statically. In case of a a tensor of rank 0 this is just the scalar
+ * type statically. In case of a tensor of rank 0 this is just the scalar
* number type Number.
*/
typedef Number array_type;
{
/**
* Duration type. Windows measures CPU times, by default, in multiples of
- * 1/64th of a second and and POSIX uses microseconds, so go with
- * microseconds for uniformity.
+ * 1/64th of a second and POSIX uses microseconds, so go with microseconds
+ * for uniformity.
*/
typedef std::chrono::microseconds duration;
/**
* Optimized replacement for <tt>std::lower_bound</tt> for searching within
* the range of column indices. Slashes execution time by approximately one
- * half for the present application, partly because because the binary
- * search is replaced by a linear search for small loop lengths.
+ * half for the present application, partly because the binary search is
+ * replaced by a linear search for small loop lengths.
*
* Another reason for this function is rather obscure: when using the GCC
* libstdc++ function std::lower_bound, complexity is O(log(N)) as required.
*
* The cells are sorted such that the centers of cells numbered higher are further
* downstream with respect to the constant vector @p direction than the
- * centers of of cells numbered lower. Even if this yields a downstream numbering with
+ * centers of cells numbered lower. Even if this yields a downstream numbering with
* respect to the flux on the edges for fairly general grids, this might not
* be guaranteed for all meshes.
*
* here.
*
* The matrix @p P is the concatenation, not the sum of the cell matrices @p
- * P_i. That is, if the same non-zero entry <tt>j,k</tt> exists in in two
+ * P_i. That is, if the same non-zero entry <tt>j,k</tt> exists in two
* different child matrices @p P_i, the value should be the same in both
* matrices and it is copied into the matrix @p P only once.
*
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.#dofs_per_face</tt> times <tt>this->#dofs_per_face</tt>.
*
* points associated with the other shape functions.
*
* In composed elements (i.e. for the FESystem class), the result will be
- * true if all all the base elements have defined support points. FE_Nothing
+ * true if all the base elements have defined support points. FE_Nothing
* is a special case in FESystems, because it has 0 support points and
* has_support_points() is false, but an FESystem containing an FE_Nothing
* among other elements will return true.
*/
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>.
*
FullMatrix<double> &matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>.
*
FullMatrix<double> &matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then @p
* dofs_per_face times <tt>source.dofs_per_face</tt>.
*
FullMatrix<double> &matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then @p
* dofs_per_face times <tt>source.dofs_per_face</tt>.
*
unsigned int get_degree () const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>.
*
FullMatrix<double> &matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>.
*
FullMatrix<double> &matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>.
*
FullMatrix<double> &matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>.
*
* single child cell is returned here.
*
* The matrix @p P is the concatenation, not the sum of the cell matrices @p
- * P_i. That is, if the same non-zero entry <tt>j,k</tt> exists in in two
+ * P_i. That is, if the same non-zero entry <tt>j,k</tt> exists in two
* different child matrices @p P_i, the value should be the same in both
* matrices and it is copied into the matrix @p P only once.
*
virtual bool hp_constraints_are_implemented () const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>.
*
FullMatrix<double> &matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the
+ * Return the matrix interpolating from a face of one element to the
* subface of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>.
*
std::vector<double> &nodal_values) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>. This
* element only provides interpolation matrices for elements of the same
FullMatrix<double> &matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>. This
* element only provides interpolation matrices for elements of the same
requires_update_flags (const UpdateFlags update_flags) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>. This
* element only provides interpolation matrices for elements of the same
FullMatrix<double> &matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>. This
* element only provides interpolation matrices for elements of the same
virtual std::string get_name () const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>. This
* element only provides interpolation matrices for elements of the same
FullMatrix<double> &matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>. This
* element only provides interpolation matrices for elements of the same
* single child cell is returned here.
*
* The matrix @p P is the concatenation, not the sum of the cell matrices @p
- * P_i. That is, if the same non-zero entry <tt>j,k</tt> exists in in two
+ * P_i. That is, if the same non-zero entry <tt>j,k</tt> exists in two
* different child matrices @p P_i, the value should be the same in both
* matrices and it is copied into the matrix @p P only once.
*
FullMatrix<double> &interpolation_matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.#dofs_per_face</tt> times <tt>this->#dofs_per_face</tt>.
*
/**
- * Return the matrix interpolating from a face of of one element to the
+ * Return the matrix interpolating from a face of one element to the
* subface of the neighboring element. The size of the matrix is then
* <tt>source.#dofs_per_face</tt> times <tt>this->#dofs_per_face</tt>.
*
DEAL_II_NAMESPACE_CLOSE
#endif
-
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>. The
* FE_Q element family only provides interpolation matrices for elements of
FullMatrix<double> &matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>. The
* FE_Q element family only provides interpolation matrices for elements of
* single child cell is returned here.
*
* The matrix @p P is the concatenation, not the sum of the cell matrices @p
- * P_i. That is, if the same non-zero entry <tt>j,k</tt> exists in in two
+ * P_i. That is, if the same non-zero entry <tt>j,k</tt> exists in two
* different child matrices @p P_i, the value should be the same in both
* matrices and it is copied into the matrix @p P only once.
*
* single child cell is returned here.
*
* The matrix @p P is the concatenation, not the sum of the cell matrices @p
- * P_i. That is, if the same non-zero entry <tt>j,k</tt> exists in in two
+ * P_i. That is, if the same non-zero entry <tt>j,k</tt> exists in two
* different child matrices @p P_i, the value should be the same in both
* matrices and it is copied into the matrix @p P only once.
*
virtual bool hp_constraints_are_implemented () const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>.
*
/**
- * Return the matrix interpolating from a face of of one element to the
+ * Return the matrix interpolating from a face of one element to the
* subface of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>.
*
&p4est_cell,
dealii::internal::p4est::functions<dim>::quadrant_compare);
- // if neither this cell nor one one of it's children belongs to us, don't do anything
+ // if neither this cell nor one of it's children belongs to us, don't do anything
if (idx == -1 && (dealii::internal::p4est::functions<dim>::
quadrant_overlaps_tree (const_cast<typename dealii::internal::p4est::types<dim>::tree *>(&tree),
&p4est_cell)
virtual bool hp_constraints_are_implemented () const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>. This
* element only provides interpolation matrices for elements of the same
FullMatrix<double> &matrix) const;
/**
- * Return the matrix interpolating from a face of of one element to the face
+ * Return the matrix interpolating from a face of one element to the face
* of the neighboring element. The size of the matrix is then
* <tt>source.dofs_per_face</tt> times <tt>this->dofs_per_face</tt>. This
* element only provides interpolation matrices for elements of the same
/**
* A typedef for the type of the divergence of the view this class
- * represents. Here, for a set of of <code>(dim*dim + dim)/2</code> unique
+ * represents. Here, for a set of <code>(dim*dim + dim)/2</code> unique
* components of the finite element representing a symmetric second-order
* tensor, the divergence of course is a * <code>Tensor@<1,dim@></code>.
*
/**
* In case the quadrature rule given represents a tensor product
* we need to store the evaluations of the 1d polynomials at the
- * the 1d quadrature quadrature points. That is what this variable is for.
+ * the 1d quadrature points. That is what this variable is for.
*/
internal::MatrixFreeFunctions::ShapeInfo<VectorizedArray<double>> shape_info;
* threshold for refinement, but only flag up to @p max_to_mark cells.
*
* The vector @p criteria contains a nonnegative value for each active cell,
- * ordered in the canonical order of of Triangulation::active_cell_iterator.
+ * ordered in the canonical order of Triangulation::active_cell_iterator.
*
* The cells are only flagged for refinement, they are not actually refined.
* To do so, you have to call
* threshold for coarsening.
*
* The vector @p criteria contains a nonnegative value for each active cell,
- * ordered in the canonical order of of Triangulation::active_cell_iterator.
+ * ordered in the canonical order of Triangulation::active_cell_iterator.
*
* The cells are only flagged for coarsening, they are not actually
* coarsened. To do so, you have to call
* which we could order as <tt>(9 6 7 10)</tt> above). However, since opposite
* lines have to have the same direction, this in turn would force us to
* rotate the cell left of it, and then the one left to that, and so on until
- * we reach the left end of the grid. This is therefore an example we we have
+ * we reach the left end of the grid. This is therefore an example we have
* to track back right until the first column of three cells to find a
* consistent ordering, if we had initially ordered them uniformly.
*
* These two examples demonstrate that if we have added a certain number of
* cells in some orientation of faces and can't add the next one without
* introducing faces that had already been added in another direction, then it
- * might not be sufficient to only rotate cells in the neighborhood of the the
+ * might not be sufficient to only rotate cells in the neighborhood of the
* cell that we failed to add. It might be necessary to go back a long way and
* rotate cells that have been entered long ago.
*
/**
* Return the point on the geometrical object @object closest to the given
* point @p trial_point. For example, if @p object is a one-dimensional line
- * or edge, then the the returned point will be a point on the geodesic that
+ * or edge, then the returned point will be a point on the geodesic that
* connects the vertices as the manifold associated with the object sees it
* (i.e., the geometric line may be curved if it lives in a higher
* dimensional space). If the iterator points to a quadrilateral in a higher
* south poles. Consider for instance the pair of points
* $x_1=(1,\pi/3,0)$ and $x_2=(1,\pi/3,\pi)$ in polar
* coordinates (lying on the surface of a sphere with radius one, on
- * a parallel at at height $\pi/3$). In this case connecting the points
+ * a parallel at height $\pi/3$). In this case connecting the points
* with a straight line in polar coordinates would take the long road
* around the globe, without passing through the north pole.
*
* cells are flagged for refinement to smooth the grid. This enlarges the
* number of resulting cells but makes the grid more regular, thus leading to
* better approximation properties and, above all, making the handling of data
- * structures and algorithms much much easier. To be honest, this is mostly an
+ * structures and algorithms much easier. To be honest, this is mostly an
* algorithmic step than one needed by the finite element method.
*
* To coarsen a grid, the same way as above is possible by using
/**
* Return whether the face with index @p face is rotated by 180 degrees (@p
- * true) or or not (@p false). In 1d and 2d, this is always @p false, but in
+ * true) or not (@p false). In 1d and 2d, this is always @p false, but in
* 3d it may be different, see the respective discussion in the
* documentation of the GeometryInfo class.
*
/**
* Return whether the face with index @p face is rotated by 90 degrees (@p
- * true) or or not (@p false). In 1d and 2d, this is always @p false, but in
+ * true) or not (@p false). In 1d and 2d, this is always @p false, but in
* 3d it may be different, see the respective discussion in the
* documentation of the GeometryInfo class.
*
const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;
/**
- * Return the square of the norm of the vector $v$ with respect to the the
+ * Return the square of the norm of the vector $v$ with respect to the
* norm induced by this matrix, i.e., $\left(v,Mv\right)$. This is useful,
* e.g., in the finite context, where the $L_2$ norm of a function equals
* the matrix norm with respect to the mass matrix of the vector
const bool transpose=false);
/**
- * Estimate the the condition number of a SPD matrix in the $l_1$-norm.
+ * Estimate the condition number of a SPD matrix in the $l_1$-norm.
* The matrix has to be in the Cholesky state (see compute_cholesky_factorization()).
* The reciprocal of the
* condition number is returned in order to avoid the possibility of
* quadrature points and cell integrations. In functionality, this class is
* similar to FEValues<dim>.
*
- * This class class has five template arguments:
+ * This class has five template arguments:
*
* @ptaram dim Dimension in which this class is to be used
*
* cell, via the first argument. Not all of the member vectors of this
* argument will be filled with data -- in fact, derivatives and other
* quantities will only be contain valid data if the corresponding flags
- * are returned by by an overloaded version of the get_needed_update_flags()
+ * are returned by an overridden version of the get_needed_update_flags()
* function (implemented in a user's derived class).
* Otherwise those vectors will be in an unspecified state.
*
* };
* @endcode
*
- * Using this class in in step-8 leads to the following visualization:
+ * Using this class in step-8 leads to the following visualization:
*
* @image html data_postprocessor_tensor_2.png
*
* There are cases where one cell contributes two tangential directions and
* another one only one; for example, this would happen if both top and
* front faces of the left cell belong to the boundary selected whereas only
- * the top face of the right cell belongs to it, maybe indicating the the
+ * the top face of the right cell belongs to it, maybe indicating that the
* entire front part of the domain is a smooth manifold whereas the top
* really forms two separate manifolds that meet in a ridge, and that
* normal-flux boundary conditions are only desired on the front manifold
*
* @param[out] j_is_current: a boolean to be filled in by setup_jacobian(). The value
* should be set to `true` if the Jacobian data is current after the call,
- * and should be set set to `false` if its Jacobian data is not current. If
+ * and should be set to `false` if its Jacobian data is not current. If
* setup_jacobian() calls for re-evaluation of Jacobian data (based on
* convfail and ARKode state data), then it should set `j_is_current` to
* `true` unconditionally, otherwise an infinite loop can result.
projects / dealii.git / commitdiff