* do_something ();
* }
* catch (exception &e) {
- * std::cerr << "Exception occured:" << std::endl
+ * std::cerr << "Exception occurred:" << std::endl
* << e.what ()
* << std::endl;
* do_something_to_reciver ();
* omitted (see previous function) and execpt of the columns that are
* previously evaluated rate columns. This function allows to evaluate the
* convergence rate for almost all columns of a table without calling
- * evaluate_convergence_rates() for each column seperately.
+ * evaluate_convergence_rates() for each column separately.
*
* Example:
* Columns like <tt>n cells</tt> or <tt>n dofs</tt> columns may be wanted to
/**
* Print more specific information about the exception which
- * occured. Overload this function in your own exception classes.
+ * occurred. Overload this function in your own exception classes.
*/
virtual void print_info (std::ostream &out) const;
* processes is redirected to the same console window. In this case,
* it is convenient to set as additional name the name of the host on
* which the program runs, so that one can see in which instance of the
- * program the exception occured.
+ * program the exception occurred.
*
* The string pointed to by the argument is copied, so doesn't need to be
* stored after the call to this function.
* $[x_0,1]$, the actual location of the
* singularity, the scale factor inside
* the logarithmic function and a flag
- * that decides wether the singularity is
+ * that decides whether the singularity is
* left inside the quadrature formula or
* it is factored out, to be included in
* the integrand.
* original quadrature, and this process is repeated for the next half
* element.
*
- * Upon construction it is possible to specify wether we want the
+ * Upon construction it is possible to specify whether we want the
* singularity removed, or not. In other words, this quadrature can be
* used to integrate $g(x) = 1/R\ f(x)$, or simply $f(x)$, with the $1/R$
* factor already included in the quadrature weights.
* the hierarchical structure of cells, which are organized in levels. In 2D we store
* information on degrees of freedom located on lines whereas in 3D we store information on
* degrees of freedom located on quads and lines. In 1D we do nothing, as the faces of
- * lines are vertices which are treated seperately.
+ * lines are vertices which are treated separately.
*
* Apart from the DoFObjects object containing the data to store (degree of freedom
* indices) we do not store any data or provide any functionality. However, we do implement
/**
* Store the indices of degrees of freedom on faces in 1D. As these would be vertices, which
- * are treted seperately, don't do anything.
+ * are treted separately, don't do anything.
*
* @author Tobias Leicht, 2006
*/
* The component_wise() function allows not only to honor enumeration based on
* vector components, but also allows to group together vector components into
* "blocks" using a defaulted argument to the various DoFRenumber::component_wise()
- * functinos (see @ref GlossComponent vs @ref GlossBlock for a description of
+ * functions (see @ref GlossComponent vs @ref GlossBlock for a description of
* the difference). The blocks designated through this argument may, but do not
* have to be, equal to the blocks that the finite element reports. For example,
* a typical Stokes element would be
/**
* Do the same thing as the corresponding
- * extract_dofs() functino for one level
+ * extract_dofs() function for one level
* of a multi-grid DoF numbering.
*/
template <class DH>
/**
* Do the same thing as the corresponding
- * extract_dofs() functino for one level
+ * extract_dofs() function for one level
* of a multi-grid DoF numbering.
*/
template <class DH>
* For all possible (isotropic and anisotropic) refinement cases compute the
* embedding matrices from a coarse cell to the child cells. Each column of
* the resulting matrices contains the representation of a coarse grid basis
- * functon by the fine grid basis; the matrices are split such that there is
+ * function by the fine grid basis; the matrices are split such that there is
* one matrix for every child.
*
* This function computes the coarse grid function in a sufficiently large
* @arg @p L: extension in @p z-direction (only used in 3d)
* @arg @p repetitions: number of subdivisions
* along the @p z-direction
- * @arg @p colorize: wether to assign different
+ * @arg @p colorize: whether to assign different
* boundary indicators to different faces.
* The colors are given in lexicographic
* ordering for the flat faces (0 to 3 in 2d,
* RefinementListener.
*
* @note The use of this class has been
- * superceded by the signals mechanism.
+ * superseded by the signals mechanism.
* See the general documentation of the
* Triangulation class for more information.
*
* class also has virtual functions.
*
* @note The use of this class has been
- * superceded by the signals mechanism.
+ * superseded by the signals mechanism.
* See the general documentation of the
* Triangulation class for more information.
*
* registered with the triangulation.
*
* @note The use of this class has been
- * superceded by the signals mechanism.
+ * superseded by the signals mechanism.
* See the general documentation of the
* Triangulation class for more information.
*
* registered with the triangulation.
*
* @note The use of this class has been
- * superceded by the signals mechanism.
+ * superseded by the signals mechanism.
* See the general documentation of the
* Triangulation class for more information.
*
* derived classes.
*
* @note The use of this class has been
- * superceded by the signals mechanism.
+ * superseded by the signals mechanism.
* See the general documentation of the
* Triangulation class for more information.
*
* implemented in derived classes.
*
* @note The use of this class has been
- * superceded by the signals mechanism.
+ * superseded by the signals mechanism.
* See the general documentation of the
* Triangulation class for more information.
*
* the Triangulation is refined.
*
* @note The use of this function has been
- * superceded by the signals mechanism.
+ * superseded by the signals mechanism.
* See the general documentation of the
* Triangulation class for more information.
*
* Triangulation.
*
* @note The use of this function has been
- * superceded by the signals mechanism.
+ * superseded by the signals mechanism.
* See the general documentation of the
* Triangulation class for more information.
*
*/
DeclException0 (ExcTriangulationNotEmpty);
/**
- * Trying to re-read a grid, an error occured.
+ * Trying to re-read a grid, an error occurred.
*
* @ingroup Exceptions
*/
* this contains nothing, in 2D it contains data
* concerning lines and in 3D quads and lines. All of
* these have no level and are therefore treated
- * seperately.
+ * separately.
*/
dealii::internal::Triangulation::TriaFaces<dim> *faces;
* independent of the hierarchical structure of cells, which are organized in levels. In 2D
* we store information on degrees of freedom located on lines whereas in 3D we store
* information on drefrees of freedom located on quads and lines. In 1D we do nothing, as
- * the faces of lines are vertices which are treated seperately.
+ * the faces of lines are vertices which are treated separately.
*
* Apart from the internal::hp::DoFObjects object containing the data to store
* (degree of freedom indices) and all the access-functionality to this data, we do not
/**
* Store the indices of degrees of freedom on faces in 1D. As these would be vertices, which
- * are treted seperately, don't do anything.
+ * are treted separately, don't do anything.
*
* @ingroup hp
* @author Tobias Leicht, 2006
* view_of_long_vector(i), with i>0 might
* cause an attempt to access invalid
* areas of memory, or might function
- * properly, depending on wether or not
+ * properly, depending on whether or not
* the system was able to allocate some
* memory consecutively after the
* original allocation.
// respectively. note that we also
// have to deal with those lines
// that are purely in the interior
- // of the ends. we determine wether
+ // of the ends. we determine whether
// an edge is purely in the
// interior if one of its vertices
// is at coordinates '+-a' as set
// first, we only collect the data
// now
- // the bool array stores, wether the lines
+ // the bool array stores, whether the lines
// are in the standard orientation or not
// note that QuadComparator is a
else
{
- // look wether it exists in
+ // look whether it exists in
// reverse direction
std::swap (line_vertices.first, line_vertices.second);
if (needed_lines.find(line_vertices) != needed_lines.end())
if (needed_lines.find(line_vertices) != needed_lines.end())
line[i] = needed_lines[line_vertices];
else
- // look wether it exists
+ // look whether it exists
// in reverse direction
{
std::swap (line_vertices.first, line_vertices.second);
/**
* Helper function for
- * @p fix_coarsen_flags. Return wether
+ * @p fix_coarsen_flags. Return whether
* coarsening of this cell is allowed.
* Coarsening can be forbidden if the
* neighboring cells are or will be
// to the common neighbor cell,
// not to its children. what we
// really want to know in the
- // following is, wether the
+ // following is, whether the
// neighbor cell is refined twice
// with reference to our cell.
// that only has to be asked, if
Its entries are indexes by the local indeces of the common face.
For example if two elements share a face, and this face is
face 0 for element 0 and face 1 for element 1, then
- table(0,1) will tell wether the orientation are the same (true) or
+ table(0,1) will tell whether the orientation are the same (true) or
opposite (false).
Even though there may be a combinatorial/graph theory argument to get
// next global loop. when this
// function terminates, the
// requirement will be
- // fullfilled. However, it might be
+ // fulfilled. However, it might be
// faster to insert an inner loop
// here.
bool changed = true;
this->solver_control.max_steps());
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
#else
- // Supress compiler warnings about unused paameters.
+ // Suppress compiler warnings about unused parameters.
(void) eps;
// PETSc/SLEPc version must be > 3.1.0.
this->solver_control.max_steps());
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
#else
- // Supress compiler warnings about unused paameters.
+ // Suppress compiler warnings about unused parameters.
(void) eps;
// PETSc/SLEPc version must be > 3.1.0.
this->solver_control.max_steps());
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
#else
- // Supress compiler warnings about unused paameters.
+ // Suppress compiler warnings about unused parameters.
(void) eps;
Assert ((false),
projects / dealii-svn.git / commitdiff