corresponding stress update. However, the rotational component does not
necessarily induce a nonzero stress update (think, in 2d, for example of the
situation where $\Delta\mathbf{u}=(y, -x)^T$, with which $\varepsilon(\Delta
-\mathbf{u})=0$). Nevertheless, if the the material was prestressed in a certain
+\mathbf{u})=0$). Nevertheless, if the material was prestressed in a certain
direction, then this direction will be rotated along with the material. To
this end, we have to define a rotation matrix $R(\Delta \mathbf{u}^n)$ that
describes, in each point the rotation due to the displacement increments. It
bottom_left,
top_right);
@endcode
-then we get images where the the fault line is curved:
+then we get images where the fault line is curved:
<TABLE WIDTH="60%" ALIGN="center">
<tr>
<td ALIGN="center">
This change requires changing the outer solver to GMRES or BiCGStab, because
the system is no longer symmetric.
-You can prescribe the the exact flow solution as $b$ in the convective term $b
+You can prescribe the exact flow solution as $b$ in the convective term $b
\cdot \nabla u$. This should give the same solution as the original problem,
if you set the right hand side to zero.
// will be only four quadrature points in each direction on the
// domain. However, the right hand side function was chosen to be rather
// localized and in that case, by pure chance, it happens that all quadrature
- // points lie at points where the the right hand side function is zero (in
+ // points lie at points where the right hand side function is zero (in
// mathematical terms, the quadrature points happen to be at points outside
// the <i>support</i> of the right hand side function). The right hand side
// vector computed with quadrature will then contain only zeroes (even though
/**
* Class that issues the set commands for AlignedVector.
*
- * @tparam initialize_memory Sets whether the the set command should
+ * @tparam initialize_memory Sets whether the set command should
* initialize memory (with a call to the copy constructor) or rather use the
* copy assignment operator. A template is necessary to select the
* appropriate operation since some classes might define only one of those
* files, the rest of the nodes will have valid set to false. The XDMF file in
* turn points to heavy data files (such as HDF5) where the actual simulation
* data is stored. This allows flexibility in arranging the data, and also
- * allows the mesh to be separated from the the point data.
+ * allows the mesh to be separated from the point data.
*/
class XDMFEntry
{
* swaps the pointers to the data of the two vectors and therefore does not
* need to allocate temporary storage and move data around.
*
- * This function is analogous to the the @p swap function of all C++
+ * This function is analogous to the @p swap function of all C++
* standard containers. Also, there is a global function <tt>swap(u,v)</tt>
* that simply calls <tt>u.swap(v)</tt>, again in analogy to standard
* functions.
void set_tex_table_label (const std::string &table_label);
/**
- * Set the caption the the supercolumn <tt>superkey</tt> for tex output.
+ * Set the caption the supercolumn <tt>superkey</tt> for tex output.
* You may want to chose this different from <tt>superkey</tt>, if it
* contains formulas or similar constructs.
*/
mutable std::map<std::string,Column> columns;
/**
- * Maps each supercolumn key to the the keys of its subcolumns in the right
+ * Maps each supercolumn key to the keys of its subcolumns in the right
* order. It is allowed that a supercolumn has got the same key as a
* column.
*
* the thread.
*
* The return value is stored in a shared_ptr because we might abandon
- * the the ThreadDescriptor. This makes sure the object stays alive
+ * the ThreadDescriptor. This makes sure the object stays alive
* until the thread exits.
*/
std::shared_ptr<return_value<RT> > ret_val;
/**
* Sort the degrees of freedom by component. It does the same thing as the
* above function, only that it does this for one single level of a
- * multilevel discretization. The non-multigrid part of the the DoFHandler
+ * multilevel discretization. The non-multigrid part of the DoFHandler
* is not touched.
*/
template <typename DoFHandlerType>
/**
* Sort the degrees of freedom by vector block. It does the same thing as
* the above function, only that it does this for one single level of a
- * multilevel discretization. The non-multigrid part of the the DoFHandler
+ * multilevel discretization. The non-multigrid part of the DoFHandler
* is not touched.
*/
template <int dim, int spacedim>
* vector that defines the mapping from the reference configuration to the
* current configuration and a reference to the DoFHandler. The vector should
* then represent a (flattened out version of a) vector valued field defined
- * at nodes defined by the the DoFHandler, where the number of components of
+ * at nodes defined by the DoFHandler, where the number of components of
* the vector field equals the number of space dimensions. Thus, the
* DoFHandler shall operate on a finite element that has as many components as
* space dimensions. As an additional requirement, we impose that it have as
const SupportQuadrature support_quadrature;
/**
- * FEValues object used to query the the given finite element field at the
+ * FEValues object used to query the given finite element field at the
* support points in the reference configuration.
*
* The variable is marked as mutable since we have to call
* iterator with the given value.
*
* If the initial value @p bi does not satisfy the predicate @p p then it is
- * advanced until we either hit the the past-the-end iterator, or the
+ * advanced until we either hit the past-the-end iterator, or the
* predicate is satisfied. This allows, for example, to write code like
* @code
* FilteredIterator<typename Triangulation<dim>::active_cell_iterator>
* to describe the manifold this object belongs to.
*
* This structure is also used to represent data for faces and edges when used
- * as a member of the the SubCellData class. In this case, the template argument
+ * as a member of the SubCellData class. In this case, the template argument
* @p structdim of an object will be less than the dimension @p dim of the
* triangulation. If this is so, then #vertices array represents the indices of
* the vertices of one face or edge of one of the cells passed to
void set_boundary (const types::manifold_id number);
/**
- * Assign a manifold object to a certain part of the the triangulation. If
+ * Assign a manifold object to a certain part of the triangulation. If
* an object with manifold number @p number is refined, this object is used
* to find the location of new vertices (see the results section of step-49
* for a more in-depth discussion of this, with examples). It is also used
* Functions that will be triggered through signals whenever the
* triangulation is modified.
*
- * Here they are used to administrate the the active_fe_fields during the
+ * Here they are used to administrate the active_fe_fields during the
* spatial refinement.
*/
void pre_refinement_action ();
*
* @dontinclude block_dynamic_sparsity_pattern.cc
*
- * After the the DoFHandler <tt>dof</tt> and the ConstraintMatrix
+ * After the DoFHandler <tt>dof</tt> and the ConstraintMatrix
* <tt>constraints</tt> have been set up with a system element, we must count
* the degrees of freedom in each matrix block:
*
* only swaps the pointers to the data of the two vectors and therefore does
* not need to allocate temporary storage and move data around.
*
- * This function is analogous to the the swap() function of all C++ standard
+ * This function is analogous to the swap() function of all C++ standard
* containers. Also, there is a global function swap(u,v) that simply calls
* <tt>u.swap(v)</tt>, again in analogy to standard functions.
*/
bool has_inhomogeneities () const;
/**
- * Return a pointer to the the vector of entries if a line is constrained,
+ * Return a pointer to the vector of entries if a line is constrained,
* and a zero pointer in case the dof is not constrained.
*/
const std::vector<std::pair<size_type,double> > *
* the same number of blocks. If needed, the numbers of blocks should be
* exchanged, too.
*
- * This function is analogous to the the swap() function of all C++
+ * This function is analogous to the swap() function of all C++
* standard containers. Also, there is a global function swap(u,v) that
* simply calls <tt>u.swap(v)</tt>, again in analogy to standard
* functions.
* only swaps the pointers to the data of the two vectors and therefore
* does not need to allocate temporary storage and move data around.
*
- * This function is analogous to the the @p swap function of all C++
+ * This function is analogous to the @p swap function of all C++
* standard containers. Also, there is a global function
* <tt>swap(u,v)</tt> that simply calls <tt>u.swap(v)</tt>, again in
* analogy to standard functions.
* For the meaning of the @p local_rows and @p local_columns parameters,
* see the PETScWrappers::MPI::SparseMatrix class documentation.
*
- * As other PETSc matrices, also the the matrix-free object needs to have
+ * As other PETSc matrices, also the matrix-free object needs to have
* a size and to perform matrix vector multiplications efficiently in
* parallel also @p local_rows and @p local_columns. But in contrast to
* PETSc::SparseMatrix classes a PETSc matrix-free object does not need
* Create a matrix object of dimensions @p m times @p n with communication
* happening over the provided @p communicator.
*
- * As other PETSc matrices, also the the matrix-free object needs to have
+ * As other PETSc matrices, also the matrix-free object needs to have
* a size and to perform matrix vector multiplications efficiently in
* parallel also @p local_rows and @p local_columns. But in contrast to
* PETSc::SparseMatrix classes a PETSc matrix-free object does not need
* the same number of blocks. If needed, the numbers of blocks should be
* exchanged, too.
*
- * This function is analogous to the the swap() function of all C++
+ * This function is analogous to the swap() function of all C++
* standard containers. Also, there is a global function swap(u,v) that
* simply calls <tt>u.swap(v)</tt>, again in analogy to standard
* functions.
* only swaps the pointers to the data of the two vectors and therefore
* does not need to allocate temporary storage and move data around.
*
- * This function is analogous to the the @p swap function of all C++
+ * This function is analogous to the @p swap function of all C++
* standard containers. Also, there is a global function
* <tt>swap(u,v)</tt> that simply calls <tt>u.swap(v)</tt>, again in
* analogy to standard functions.
* only swaps the pointers to the data of the two vectors and therefore
* does not need to allocate temporary storage and move data around.
*
- * This function is analogous to the the @p swap function of all C++
+ * This function is analogous to the @p swap function of all C++
* standard containers. Also, there is a global function
* <tt>swap(u,v)</tt> that simply calls <tt>u.swap(v)</tt>, again in
* analogy to standard functions.
std::vector<number> diag;
/**
- * Inverses of the the diagonal: precomputed for faster vmult.
+ * Inverses of the diagonal: precomputed for faster vmult.
*/
std::vector<number> inv_diag;
* the same number of blocks. If needed, the numbers of blocks should be
* exchanged, too.
*
- * This function is analogous to the the swap() function of all C++
+ * This function is analogous to the swap() function of all C++
* standard containers. Also, there is a global function swap(u,v) that
* simply calls <tt>u.swap(v)</tt>, again in analogy to standard
* functions.
* a ghosted vector may not even store all of the elements a non- ghosted
* vector would store on the current processor. Consequently, for
* Trilinos vectors, there is no notion of an 'owner' of vector elements
- * in the way we have it in the the non-ghost case view.
+ * in the way we have it in the non-ghost case view.
*
* This explains why we do not allow writing into ghosted vectors on the
* Trilinos side: Who would be responsible for taking care of the
* does not need to allocate temporary storage and move data around. Note
* that the vectors need to be of the same size and base on the same map.
*
- * This function is analogous to the the @p swap function of all C++
+ * This function is analogous to the @p swap function of all C++
* standard containers. Also, there is a global function
* <tt>swap(u,v)</tt> that simply calls <tt>u.swap(v)</tt>, again in
* analogy to standard functions.
* swaps the pointers to the data of the two vectors and therefore does not
* need to allocate temporary storage and move data around.
*
- * This function is analogous to the the @p swap function of all C++
+ * This function is analogous to the @p swap function of all C++
* standard containers. Also, there is a global function <tt>swap(u,v)</tt>
* that simply calls <tt>u.swap(v)</tt>, again in analogy to standard
* functions.
/**
* Return a read and write pointer to the first field of the dof values.
* This is the data field the read_dof_values() functions write into. First
- * come the the dof values for the first component, then all values for the
+ * come the dof values for the first component, then all values for the
* second component, and so on. This is related to the internal data
* structures used in this class. In general, it is safer to use the
* get_dof_value() function instead.
/**
* Implementation of the interface for @p Multigrid. This function does
* nothing, which by comparison with the definition of this function means
- * that the the smoothing operator equals the null operator.
+ * that the smoothing operator equals the null operator.
*/
virtual void smooth (const unsigned int level,
BlockVector<number> &u,
/**
* Implementation of the interface for @p Multigrid. This function does
* nothing, which by comparison with the definition of this function means
- * that the the smoothing operator equals the null operator.
+ * that the smoothing operator equals the null operator.
*/
virtual void smooth (const unsigned int level,
VectorType &u,
L1_norm,
/**
- * The square of the function is integrated and the the square root of the
+ * The square of the function is integrated and the square root of the
* result is computed on each cell:
* @f[
* E_K = \sqrt{ \int_K \sum_c e_c^2 \, w_c }
// add the required number of
// patches. first initialize a template
- // patch with n_q_points (in the the plane
+ // patch with n_q_points (in the plane
// of the cells) times n_subdivisions+1 (in
// the time direction) points
dealii::DataOutBase::Patch<dim+1,dim+1> default_patch;
};
- // now fill in the the data values.
+ // now fill in the data values.
// note that the required order is
// with highest coordinate running
// fastest, we need to enter each
// ---------------------------------------------------------------------
-// same as the the test with number _01, but check for block vectors
+// same as the test with number _01, but check for block vectors
#include "../tests.h"
// ---------------------------------------------------------------------
-// same as the the test with number _01, but check for block vectors
+// same as the test with number _01, but check for block vectors
#include "../tests.h"
#include "data_out_common.h"
// ---------------------------------------------------------------------
-// same as the the test with number _01, but check for block vectors
+// same as the test with number _01, but check for block vectors
#include "../tests.h"
projects / dealii.git / commitdiff