* if we call @p{memory_consumption(v)} on a vector @p{v} of type
* @p{FullMatrix<double>}, we first reduce this to a loop in which we
* call @p{memory_consumption(v[i])}, and because there is no such
- * function handling this explicitely, we try to call
+ * function handling this explicitly, we try to call
* @p{v[i].memory_consumption()}.
*
*
/**
* For all other types which are
- * not explicitely listed: try if
+ * not explicitly listed: try if
* there is a member function
* called
* @p{memory_consumption}. If
/**
* 6-Point-Gauss quadrature formula, exact for polynomials of degree 11.
- * I have not found explicite
+ * We have not found explicit
* representations of the zeros of the Legendre functions of sixth
* and higher degree. If anyone finds them, please replace the existing
* numbers by these expressions.
/**
* 7-Point-Gauss quadrature formula, exact for polynomials of degree 13.
- * I have not found explicite
+ * We have not found explicit
* representations of the zeros of the Legendre functions of sixth
* and higher degree. If anyone finds them, please replace the existing
* numbers by these expressions.
// then write data.
// the '1' means: node data (as opposed
// to cell data, which we do not
- // support explicitely here)
+ // support explicitly here)
for (unsigned int data_set=0; data_set<n_data_sets; ++data_set)
{
out << data_names[data_set] << " 1" << std::endl;
// then write data. the
// 'POINTD_DATA' means: node data
// (as opposed to cell data, which
- // we do not support explicitely
+ // we do not support explicitly
// here). all following data sets
// are point data
out << "POINT_DATA " << n_nodes
Quadrature<dim> (QWeddle<dim-1>(), QWeddle<1>()){};
-// explicite specialization
+// explicit specialization
// note that 1d formulae are specialized by implementation above
template class QGauss<2>;
template class QGauss2<2>;
*
* The matrix is organized in lines (rows), but only those lines are stored
* where constraints are present. Lines where only one entry (identity) is
- * present are not stored if not explicitely inserted.
+ * present are not stored if not explicitly inserted.
*
* Constraint matrices are used to handle hanging nodes and other constrained
* degrees of freedom. When building the global system matrix and the right
* with zeroes in the lines subject to constraints. Additionally, the vector
* size is larger than in the first possibility, resulting in more memory
* consumption for those iterative solution methods using a larger number of
- * auxiliary vectors (e.g. methods using explicite orthogonalization
+ * auxiliary vectors (e.g. methods using explicit orthogonalization
* procedures).
* @end{itemize}
*
* Number of this line. Since only very
* few lines are stored, we can not
* assume a specific order and have
- * to store the line number explicitely.
+ * to store the line number explicitly.
*/
unsigned int line;
/**
* Store the indices of the degrees of freedom which are located on the lines.
* Declare it to have a template parameter, but do not actually declare
- * other types than those explicitely instantiated.
+ * other types than those explicitly instantiated.
*
* @author Wolfgang Bangerth, 1998
*/
* order in the space of points
* (except for the 1d case), you
* have to provide a map with an
- * explicitely specified
+ * explicitly specified
* comparator object. This
* function is therefore
* templetized on the comparator
/**
* Comparison operator. It is not clear to
* me (WB) why we have to declare and implement
- * this one explicitely.
+ * this one explicitly.
*/
//TODO:[WB] (compiler) remove operator and let the compiler generate it as soon as it is willing to do so
bool operator == (const FiniteElementData<dim> &) const;
* The implementation of this base class is split into two parts:
* those fields which are not common to all dimensions
* (@p{dofs_per_quad} for example are only useful for @p{dim>=2}) are put
- * into the @p{FiniteElementData<dim>} class which is explicitely
+ * into the @p{FiniteElementData<dim>} class which is explicitly
* specialized for all used dimensions, while those fields which may
* be formulated in a dimension-independent way are put into the
* present class.
/**
* Construct an object of this type.
* You have to set the
- * matrices explicitely after calling
+ * matrices explicitly after calling
* this base class' constructor.
*/
FiniteElementBase (const FiniteElementData<dim> &fe_data,
* numbering. However, the shape functions on a cell are renumbered
* beginning with the shape functions whose support points are at the
* vertices, then on the line, on the quads, and finally (for 3d) on
- * the hexes. To be explicite, these numberings are listed in the
+ * the hexes. To be explicit, these numberings are listed in the
* following:
*
* @sect4{Q1 elements}
* @p{MappingQ1} object. Needed
* by constructors of derived
* classes that uses
- * @p{MappingQ1} implicitely.
+ * @p{MappingQ1} implicitly.
*/
static const Mapping<dim> &get_default_mapping();
};
/**
* When writing a mesh, write boundary
- * faces explicitely if their boundary
+ * faces explicitly if their boundary
* indicator is not the default
* boundary indicator, which is zero.
* This is necessary if you later
/**
* Flags describing the details of
* output for encapsulated postscript
- * for all dimensions not explicitely
+ * for all dimensions not explicitly
* specialized below. Some flags that
* are common to all dimensions are
* listed in the base class.
* whether boundary faces with
* non-zero boundary indicator
* shall be written to the file
- * explicitely. This is useful,
+ * explicitly. This is useful,
* if you want to re-read the
* grid later on, since
* @p{deal.II} sets the boundary
* same triangulation as before,
* you have to specify faces
* with differing boundary
- * indicators explicitely, which
+ * indicators explicitly, which
* is done by this flag.
*
* Names and values of further
* Return the number of faces in the
* triangulation which have a boundary
* indicator not equal to zero. Only
- * these faces are explicitely printed
+ * these faces are explicitly printed
* in the @p{write_*} functions;
* all faces with indicator 255 are
* interior ones and an indicator with
* @end{verbatim}
*
* Note that the template parameters to this class have to be given as
- * @p{InterGridMap<DoFHandler,2>}, i.e. the dimension is given explicitely and
+ * @p{InterGridMap<DoFHandler,2>}, i.e. the dimension is given explicitly and
* no dimension is attributed to the first parameter, which here is
* @ref{DoFHandler} (and could equally well be @ref{Triangulation} or @ref{MGDoFHandler}).
*
* This class implements some types which differ between the
* dimensions. Declare it to have a template parameter, but do not
* actually declare anything concrete apart from the other classes
- * which are explicitely instantiated ones with the same name.
+ * which are explicitly instantiated ones with the same name.
*
* @author Wolfgang Bangerth, 1998
*/
* etc.) denote all cells the material id zero. You may change that afterwards,
* but you should not use the material id 255. When reading a triangulation,
* the material id must be specified in the input file (UCD format) or is
- * otherwise set to zero. When creating explicitely, the material id must
+ * otherwise set to zero. When creating explicitly, the material id must
* be given to the creation function.
*
* Regarding the boundary indicator for lines in two dimensions and quads
* different boundary indicators to the triangulation creation function.
* The standard domain functions assume all faces to have boundary indicator
* zero, which you may change manually afterwards. When reading from a file,
- * you have to give boundary indicators other than zero explicitely, e.g. in
+ * you have to give boundary indicators other than zero explicitly, e.g. in
* UCD format by giving a list of lines with material id in the input file.
*
* Lines in two dimensions and quads in three dimensions inherit their
*
* A heaxhedron itself has one index, as far as the topological part handled in
* the triangulation is concerned: the index in the level
- * it belongs to. The level index is implicitely given by the position
+ * it belongs to. The level index is implicitly given by the position
* in the @p{hexes.hexes} list attached to the information of each level
* of the triangulation.
*
* Usage is thus like @p{(*i).index ();}
*
* This function has to be specialized
- * explicitely for the different
+ * explicitly for the different
* @p{Pointee}s, to allow an
* @p{iterator<1,TriangulationLevel<1>::LinesData>}
* to point to @p{tria->lines.lines[index]} while
* append the needed elements.
* There are pendants for higher
* dimensions, which you have to call
- * explicitely (they can't hand down the
+ * explicitly (they can't hand down the
* call because there is no easy relation
* between the number of new quads and
* the number of new lines, etc.). Also
*
* A line itself has one index, as far as the topological part handled in
* the triangulation is concerned: the index in the level
- * it belongs to. The level index is implicitely given by the position
+ * it belongs to. The level index is implicitly given by the position
* in the @p{lines.lines} list attached to the information of each level.
*
* @author Wolfgang Bangerth, 1998
*
* A quad itself has one index, as far as the topological part handled in
* the triangulation is concerned: the index in the level
- * it belongs to. The level index is implicitely given by the position
+ * it belongs to. The level index is implicitly given by the position
* in the @p{quads.quads} list attached to the information of each level
* of the triangulation.
*
* abovementioned map of integrals as well. This consumes some memory more
* than needed, but makes the summing up of the face contributions to the
* cells easier, since then we have the information from all faces of all
- * cells at hand and need not think about explicitely determining whether
+ * cells at hand and need not think about explicitly determining whether
* a face was refined or not. The same applies for boundary faces, see
* above.
*
* function call teh given function with
* the specified parameter. Note that you
* need to bind the second parameter since
- * the first one implicitely contains
+ * the first one implicitly contains
* the object which the function is to
* be called for.
*/
// respective dofs of the other
// components have sum of weights
// zero, of course. we do not
- // explicitely ask which component
+ // explicitly ask which component
// a dof belongs to, but this at
// least tests some errors
#ifdef DEBUG
// coarsening is possible or deleted
// otherwise. Coarsen flags of cells with
// no mother cell, i.e. on the
- // coarsest level are deleted explicitely.
+ // coarsest level are deleted explicitly.
clear_user_flags ();
// number of active children of @p{cell}.
// number of children of @p{cell} which are
#endif
-// explicite instantiations
+// explicit instantiations
template class MGDoFHandler<deal_II_dimension>;
projects / dealii-svn.git / commitdiff