This should be a majority of the typos in the documentation.
mg_matrix_dg_down.clear();
// It is important to update the sparsity patterns after <tt>clear()</tt>
// was called for the level matrices, since the matrices lock the sparsity
- // pattern through the Smartpointer and Subscriptor mechanism.
+ // pattern through the SmartPointer and Subscriptor mechanism.
mg_sparsity.resize(0, n_levels-1);
mg_sparsity_dg_interface.resize(0, n_levels-1);
\f}
with ${\hat R}\left({\mathbf u}\right)=\left(P_{Pi}(C\varepsilon(u)),\varepsilon(\varphi^{i}_p\right)$ with
the exceptions of (i) elements $p\in\mathcal{A}_i$ where we set ${\hat R}\left({\mathbf u}\right)=0$,
- and (ii) elements that correpond to hanging nodes, which we eliminate in the usual manner.
+ and (ii) elements that correspond to hanging nodes, which we eliminate in the usual manner.
<li> Define the new active and inactive sets by
@f{gather*}\mathcal{A}_{i+1}:=\lbrace p\in\mathcal{S}:\Lambda^i_p +
Other than that, let us comment only on the following aspects:
<ul>
<li> The program allows you to select from two different coarse meshes
- through the parameter file. These are eiter a cube $[0,1]^3$ or
+ through the parameter file. These are either a cube $[0,1]^3$ or
a half sphere with the open side facing the positive $z$ direction.
<li>In either case, we will assume the convention that the part of the
The tables at the end of each cycle show information about computing time
and the number of calls of different parts of the program like assembly or
calculating the residual, for the most recent mesh refinement cycle. Some of
-the numbers above can be improved by transfering the solution from one mesh to
+the numbers above can be improved by transferring the solution from one mesh to
the next, an option we have not exercised here. Of course, you can also make
the program run faster, especially on the later refinement cycles, by just
using more processors: the accompanying paper shows good scaling to at least
// for the finite element are located. We achieve this by using a
// QGaussLobatto quadrature formula here, along with initializing the finite
// element with a set of interpolation points derived from the same quadrature
- // formula. The remainder of the function is relatively straightfoward: we
+ // formula. The remainder of the function is relatively straightforward: we
// put the resulting matrix into the given argument; because we know the
// matrix is diagonal, it is sufficient to have a loop over only $i$ not
// not over $j$. Strictly speaking, we could even avoid multiplying the
// residual (newton_rhs_uncondensed) and corresponding diagonal entry
// of the mass matrix (diag_mass_matrix_vector). Because it is
// not unlikely that hanging nodes show up in the contact area
- // it is important to apply contraints_hanging_nodes.distribute
+ // it is important to apply constraints_hanging_nodes.distribute
// to the distributed_lambda vector.
template <int dim>
void
// for each degree of freedom. Due to the way the ConstraintMatrix
// stores its data, the function to add a constraint on a single
// degree of freedom and force it to be zero is called
- // Constraintmatrix::add_line(); doing so for several degrees of
+ // ConstraintMatrix::add_line(); doing so for several degrees of
// freedom at once can be done using
- // Constraintmatrix::add_lines():
+ // ConstraintMatrix::add_lines():
std::vector<ConstraintMatrix> boundary_constraints (triangulation.n_global_levels());
std::vector<ConstraintMatrix> boundary_interface_constraints (triangulation.n_global_levels());
for (unsigned int level=0; level<triangulation.n_global_levels(); ++level)
at relatively high order, despite their focus on a discontinuous (and hence,
seemingly low accurate) representation of solutions.
-<h4>Resuls for 3D</h4>
+<h4>Results for 3D</h4>
We now show the same figures in 3D: The first row shows the number of degrees
of freedom and computing time versus the $L_2$ error in the scalar variable
// The degrees of freedom corresponding to the skeleton strongly enforce
// Dirichlet boundary conditions, just as in a continuous Galerkin finite
// element method. We can enforce the boundary conditions in an analogous
- // manner through the use of <code>ConstrainMatrix</code> constructs. In
+ // manner through the use of <code>ConstraintMatrix</code> constructs. In
// addition, hanging nodes are handled in the same way as for
// continuous finite elements: For the face elements which
// only define degrees of freedom on the face, this process sets the
// and matrix that are written into the global matrix, whereas the
// ScratchData contains all data that we need for the local assembly. There
// is one variable worth noting here, namely the boolean variable @p
- // trace_reconstruct. As mentioned in the introdution, we solve the HDG
+ // trace_reconstruct. As mentioned in the introduction, we solve the HDG
// system in two steps. First, we create a linear system for the skeleton
// system where we condense the local part into it via the Schur complement
// $D-CA^{-1}B$. Then, we solve for the local part using the skeleton
// @sect4{HDG::output_results}
// We have 3 sets of results that we would like to output: the local solution,
// the post-processed local solution, and the skeleton solution. The former 2
- // both 'live' on element volumes, wheras the latter lives on codimention-1 surfaces
+ // both 'live' on element volumes, whereas the latter lives on codimension-1 surfaces
// of the triangulation. Our @p output_results function writes all local solutions
// to the same vtk file, even though they correspond to different <code>DoFHandler</code>
// objects. The graphical output for the skeleton variable is done through
face_out += ".vtk";
std::ofstream face_output (face_out.c_str());
-// The <code>DataOutFaces</code> class works analagously to the <code>DataOut</code>
+// The <code>DataOutFaces</code> class works analogously to the <code>DataOut</code>
// class when we have a <code>DoFHandler</code> that defines the solution on
// the skeleton of the triangulation. We treat it as such here, and the code is
// similar to that above.
// @sect4{<code>Diffusion::embedded_explicit_method</code>}
- // This function is the driver for the embedded explict methods. It requires
+ // This function is the driver for the embedded explicit methods. It requires
// more parameters:
// - coarsen_param: factor multiplying the current time step when the error
// is below the threshold.
case of ships, the domain is the water surrounding the ship with its rudders
and propellers.
- The other of the two big applications of the finite element method is
- structural engineering in which the domains are bridges, airplane necelles
+ structural engineering in which the domains are bridges, airplane nacelles
and wings, and other solid bodies of often complicated shapes.
- Finite element modeling is also often used to describe the generation and
propagation of earthquake waves. In these cases, one needs to accurately
// The next step is to explain to the triangulation to use our geometry
// object whenever a new point is needed upon refining the mesh. We do
- // this by telling the triangulation to use our geometry for everythin
+ // this by telling the triangulation to use our geometry for everything
// that has manifold indicator zero, and then proceed to mark all cells
// and their bounding faces and edges with manifold indicator zero. This
- // ensures that the triangulation consults our geometry object everytime
+ // ensures that the triangulation consults our geometry object every time
// a new vertex is needed. Since manifold indicators are inherited from
// mother to children, this also happens after several recursive
// refinement steps.
onto the specified geometry.
Differently from a spherical or circular boundary, a boundary with a complex
-geometry poses proplems as to where it is best to place the new nodes created
+geometry poses problems as to where it is best to place the new nodes created
upon refinement on the prescribed shape. HyperBallBoundary first creates the
new nodes on the face or edge to be refined by averaging the surrounding
points in the same way as FlatManifold does. Then, it goes on to project such
<img src="http://www.dealii.org/images/steps/developer/step-54.CurveSplit.png" alt="" width="500">
-A different projection stategy has been implemented in the
+A different projection strategy has been implemented in the
OpenCASCADE::NormalProjectionBoundary class. The <code>TopoDS_Shape</code>
assigned at construction time can be arbitrary (a collection of shapes, faces,
edges or a single face or edge will all work). The new cell nodes are first
least a face) and a direction along which all the projections will be carried
out. New points will be computed by first averaging the surrounding points (as
in the FlatManifold case), and then taking the closest intersection between
-the topological shape and the line passing throught the resulting point, along
+the topological shape and the line passing through the resulting point, along
the direction used at construction time. In this way, the user will have a
higher control on the projection direction to be enforced to ensure good mesh
quality.
OpenCASCADE::NormalToMeshProjectionBoundary class implements a third
projection algorithm. The OpenCASCADE::NormalToMeshProjectionBoundary class is
built assigning a <code>TopoDS_Shape</code> (containing at least one face) to
-the contructor, and works exactly like a
+the constructor, and works exactly like a
OpenCASCADE::DirectionalProjection. But, as the name of the class suggests,
OpenCASCADE::NormalToMeshProjectionBoundary tries to come up with a suitable
estimate of the direction normal to the mesh elements to be refined, and uses
extended this concept in 3D, and project all new nodes in a direction that
approximates the cell normal.
-In the next figure, which is inpired by the geometry considered in this
+In the next figure, which is inspired by the geometry considered in this
tutorial, we make an attempt to compare the behavior of the three projectors
considered. As can be seen on the left, given the original cell (in blue), the
new point found with the normal projection is in a position which does not
// The mesh imported has a single, two-dimensional cell located in
// three-dimensional space. We now want to ensure that it is refined
// according to the CAD geometry imported above. This this end, we get an
- // iterator to that cell and assgin to it the manifold_id 1 (see
+ // iterator to that cell and assign to it the manifold_id 1 (see
// @ref GlossManifoldIndicator "this glossary entry").
// We also get an iterator to its four faces, and assign each of them
// the manifold_id 2:
/**
* @brief Find index of a named object
*
- * Try to find the objecty and return its index in the list. Throw an
+ * Try to find the object and return its index in the list. Throw an
* exception if the object has not been found.
*/
unsigned int find(const std::string &name) const;
/**
* @brief Try to find index of a named object
*
- * Try to find the objecty and return its index in the list. returns
+ * Try to find the object and return its index in the list. returns
* numbers::invalid_unsigned_int if the name was not found.
*/
unsigned int try_find(const std::string &name) const;
*
* Furthermore note, that an object of this class does <b>not</b> represent
* the derivative of a function, like FunctionDerivative, that gives a
- * directional derivate by calling the value() function. In fact, this class
+ * directional derivative by calling the value() function. In fact, this class
* (the AutoDerivativeFunction class) can substitute the Function class as
* base class for user defined classes. This class implements the gradient()
* functions for automatic computation of numerical difference quotients and
* the convergence rates of `all' columns (see the following two functions).
*
* The Column::flag==1 is reserved for omitting the column from convergence
- * rate evalution.
+ * rate evaluation.
*/
void
omit_column_from_convergence_rate_evaluation(const std::string &key);
* Evaluates convergence rates due to the <tt>rate_mode</tt> in relation to
* the reference column <tt>reference_column_key</tt>. This function
* evaluates the rates of ALL columns except of the columns that are to be
- * omitted (see previous function) and execpt of the columns that are
+ * omitted (see previous function) and except 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 separately.
/**
* Evaluates convergence rates due to the <tt>rate_mode</tt>. This function
* evaluates the rates of ALL columns except of the columns that are to be
- * omitted (see previous function) and execpt of the columns that are
+ * omitted (see previous function) and except 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 separately.
* order, <i>x</i> running fastest, then <i>y</i> and <i>z</i>. Nodes are
* stored in this order and cells as well. Each cell in 3D is stored such that
* the front face is in the <i>xz</i>-plane. In order to enhance
- * intellegibility of this concept, the following two sections are kept from a
+ * intelligibility of this concept, the following two sections are kept from a
* previous version of this documentation.
*
*
*
* See the general documentation of the DataOutBase class for more
* information on its contents and purposes. In the case of two dimensions,
- * the next picture ist an example of <tt>n_subdivision</tt> = 4 because the
+ * the next picture is an example of <tt>n_subdivision</tt> = 4 because the
* number of (sub)cells within each patch is equal to
* <tt>2<sup>dim</sup></tt>.
*
/**
* Default colorization function. This one does what one usually wants: It
* shifts colors from black (lowest value) through blue, green and red to
- * white (highest value). For the exact defition of the color scale refer
+ * white (highest value). For the exact definition of the color scale refer
* to the implementation.
*
* This function was originally written by Stefan Nauber.
struct Deal_II_IntermediateFlags : public OutputFlagsBase<Deal_II_IntermediateFlags>
{
/**
- * An indicator of the currect file format version used to write
+ * An indicator of the current file format version used to write
* intermediate format. We do not attempt to be backward compatible, so
* this number is used only to verify that the format we are writing is
* what the current readers and writers understand.
/**
* Write the given list of patches to the output stream in gnuplot format.
* Visualization of two-dimensional data can then be achieved by starting
- * <tt>gnuplot</tt> and endtering the commands
+ * <tt>gnuplot</tt> and entering the commands
*
* @verbatim
* set data style lines
* declared somewhere before the object data. This may be in an external
* data file or at the beginning of the output file. Setting the
* <tt>external_data</tt> flag to false, an standard camera, light and
- * texture (scaled to fit the scene) is added to the outputfile. Set to true
+ * texture (scaled to fit the scene) is added to the output file. Set to true
* an include file "data.inc" is included. This file is not generated by
* deal and has to include camera, light and the texture definition Tex.
*
*
* The functions offering the different output format names are, respectively,
* <tt>default_suffix</tt>, <tt>parse_output_format</tt>, and
- * <tt>get_output_format_names</tt>. They make the selection of ouput formats
+ * <tt>get_output_format_names</tt>. They make the selection of output formats
* in parameter files much easier, and especially independent of the formats
* presently implemented. User programs need therefore not be changed whenever
* a new format is implemented.
"information.");
/**
- * Some of our numerical classes allow for setting alll entries to zero
+ * Some of our numerical classes allow for setting all entries to zero
* using the assignment operator <tt>=</tt>.
*
* In many cases, this assignment operator makes sense <b>only</b> for the
class StokesLSingularity : public FlowFunction<2>
{
public:
- /// Constructor setting upsome data.
+ /// Constructor setting up some data.
StokesLSingularity();
virtual void vector_values (const std::vector<Point<2> > &points,
* here, the given function object is still a scalar function (i.e. it has a
* single value at each space point) but that the Function object generated is
* vector valued. The number of vector components is specified in the
- * constructor, where one also selectes a single one of these vector
+ * constructor, where one also selects a single one of these vector
* components that should be filled by the passed object. The result is a
* vector Function object that returns zero in each component except the
* single selected one where it returns the value returned by the given as the
{
public:
/**
- * A subclass allowing for the safe generation and removal of prefices.
+ * A subclass allowing for the safe generation and removal of prefixes.
*
* Somewhere at the beginning of a block, create one of these objects, and
* it will appear as a prefix in LogStream output like @p deallog. At the
/**
* Maximum number of levels to be written to the log file. The functionality
* is the same as <tt>depth_console</tt>, nevertheless, this function should
- * be used with care, since it may spoile the value of a log file.
+ * be used with care, since it may spoil the value of a log file.
*
* The previous value of this parameter is returned.
*/
/**
* set the precision for the underlying stream and returns the previous
- * stream precision. This fuction mimics
+ * stream precision. This function mimics
* http://www.cplusplus.com/reference/ios/ios_base/precision/
*/
std::streamsize precision (const std::streamsize prec);
/**
* set the width for the underlying stream and returns the previous stream
- * width. This fuction mimics
+ * width. This function mimics
* http://www.cplusplus.com/reference/ios/ios_base/width/
*/
std::streamsize width (const std::streamsize wide);
/**
* set the flags for the underlying stream and returns the previous stream
- * flags. This fuction mimics
+ * flags. This function mimics
* http://www.cplusplus.com/reference/ios/ios_base/flags/
*/
std::ios::fmtflags flags(const std::ios::fmtflags f);
/**
* Internal wrapper around "thread local" outstreams. This private function
- * will return the correct internal ostringstream buffer for operater<<.
+ * will return the correct internal ostringstream buffer for operator<<.
*/
std::ostringstream &get_stream();
* memory_consumption() will simply call the member function of same name. It
* is up to the implementation of the data type to provide a good estimate of
* the amount of memory used. Inside this function, the use of
- * MemoryConsumpton::memory_consumption() for compounds of the class helps to
+ * MemoryConsumption::memory_consumption() for compounds of the class helps to
* obtain this estimate. Most classes in the deal.II library have such a
* member function.
*
* set Nonlinear method = Gradient
* # this is a comment
* subsection Linear solver
- * set Solver = CG
- * set Maxmimum number of iterations = 30
+ * set Solver = CG
+ * set Maximum number of iterations = 30
* end
* end
* ... # other stuff
* parameters at the beginning of a log file, since this way input and output
* are together in one file which makes matching at a later time easier.
* Additionally, the function also print those entries which have not been
- * modified in the input file und are thus set to default values; since
+ * modified in the input file and are thus set to default values; since
* default values may change in the process of program development, you cannot
* know the values of parameters not specified in the input file.
*
*
* <h3>Representation of Parameters</h3>
*
- * Here is some more internal information about the repesentation of
+ * Here is some more internal information about the representation of
* parameters:
*
* Logically, parameters and the nested sections they are arranged in can be
/**
* Traverse the section currently set by
* enter_subsection()/leave_subsection() and see which of the entries are
- * variante/array entries. Then fill the multiple_choices variable using
+ * variant or array entries. Then fill the multiple_choices variable using
* this information.
*/
void init_branches_current_section ();
* Parse parameters needed by this class. If the number of components
* which is parsed does not match the number of components of this object,
* an assertion is thrown and the program is aborted. In order for the
- * class to function properly, we follow the same convenctions declared in
+ * class to function properly, we follow the same conventions declared in
* the FunctionParser class (look there for a detailed description of the
* syntax for function declarations).
*
{
public:
/**
- * Constructor. Takes the degree <tt>n</tt> of the Lagrangian polynom and
- * the index <tt>support_point</tt> of the support point. Fills the
+ * Constructor. Takes the degree <tt>n</tt> of the Lagrangian polynomial
+ * and the index <tt>support_point</tt> of the support point. Fills the
* <tt>coefficients</tt> of the base class Polynomial.
*/
LagrangeEquidistant (const unsigned int n,
private:
/**
- * Store the coefficients of the polynominals in the order
+ * Store the coefficients of the polynomials in the order
* $1,x,y,x^2,y^2,xy,x^3,y^3,xy^2,x^2y,x^3y,xy^3$
*/
Table<2, double> coef;
/**
- * Store the coefficients of the x-derivative of the polynominals in the
+ * Store the coefficients of the x-derivative of the polynomials in the
* order $1,x,y,x^2,y^2,xy,x^3,y^3,xy^2,x^2y,x^3y,xy^3$
*/
Table<2, double> dx;
/**
- * Store the coefficients of the y-derivative of the polynominals in the
+ * Store the coefficients of the y-derivative of the polynomials in the
* order $1,x,y,x^2,y^2,xy,x^3,y^3,xy^2,x^2y,x^3y,xy^3$
*/
Table<2, double> dy;
/**
- * Store the coefficients of the second x-derivative of the polynominals in
+ * Store the coefficients of the second x-derivative of the polynomials in
* the order $1,x,y,x^2,y^2,xy,x^3,y^3,xy^2,x^2y,x^3y,xy^3$
*/
Table<2, double> dxx;
/**
- * Store the coefficients of the second y-derivative of the polynominals in
+ * Store the coefficients of the second y-derivative of the polynomials in
* the order $1,x,y,x^2,y^2,xy,x^3,y^3,xy^2,x^2y,x^3y,xy^3$
*/
Table<2, double> dyy;
/**
- * Store the coefficients of the second mixed derivative of the polynominals
+ * Store the coefficients of the second mixed derivative of the polynomials
* in the order $1,x,y,x^2,y^2,xy,x^3,y^3,xy^2,x^2y,x^3y,xy^3$
*/
Table<2, double> dxy;
*
* Which one of the two sets of weights is provided, can be selected by the @p
* factor_out_singular_weight parameter. If it is false (the default), then
- * the $\bar{w}_i$ weigths are computed, and you should provide only the
+ * the $\bar{w}_i$ weights are computed, and you should provide only the
* smooth function $f(x)$, since the singularity is included inside the
* quadrature. If the parameter is set to true, then the singularity is
* factored out of the quadrature formula, and you should provide a function
{
public:
/**
- * The constructor takes four arguments: the order of the gauss formula on
+ * The constructor takes four arguments: the order of the Gauss formula on
* each of the segments $[0,x_0]$ and $[x_0,1]$, the actual location of the
* singularity, the scale factor inside the logarithmic function and a flag
* that decides whether the singularity is left inside the quadrature
private:
/**
- * Pointer to the object we want to subscribt to. Since it is often
+ * Pointer to the object we want to subscribe to. Since it is often
* necessary to follow this pointer when debugging, we have deliberately
* chosen a short name.
*/
map_iterator;
/**
- * Store the number of objects which subscribed to this object. Initialally,
+ * Store the number of objects which subscribed to this object. Initially,
* this number is zero, and upon destruction it shall be zero again (i.e.
* all objects which subscribed should have unsubscribed again).
*
iterator begin () const;
/**
- * Return an interator to the element past the end of this row.
+ * Return an iterator to the element past the end of this row.
*/
iterator end () const;
* - <code>simple_table_with_separate_column_description</code>: This format
* is very similar to <code>table_with_separate_column_description</code>,
* but it skips aligning the columns with additional white space. This
- * increases the performance o fwrite_text() for large tables. Example
+ * increases the performance of write_text() for large tables. Example
* output:
* @code
* # 1: key1
* Cross-product in 2d. This is just a rotation by 90 degrees clockwise to
* compute the outer normal from a tangential vector. This function is defined
* for all space dimensions to allow for dimension independent programming
- * (e.g. within switches over the space dimenion), but may only be called if
+ * (e.g. within switches over the space dimension), but may only be called if
* the actual dimension of the arguments is two (e.g. from the <tt>dim==2</tt>
* case in the switch).
*
/**
* Cross-product of 2 vectors in 3d. This function is defined for all space
* dimensions to allow for dimension independent programming (e.g. within
- * switches over the space dimenion), but may only be called if the actual
+ * switches over the space dimension), but may only be called if the actual
* dimension of the arguments is three (e.g. from the <tt>dim==3</tt> case in
* the switch).
*
private:
/**
* Store the values in a simple array. For <tt>dim==0</tt> store one
- * element, because otherways the compiler would choke. We catch this case
+ * element, because otherwise the compiler would choke. We catch this case
* in the constructor to disallow the creation of such an object.
*/
Number values[(dim!=0) ? (dim) : (dim+1)];
* management and synchronization classes instead when running in single-
* thread mode. Specifically, the new_thread() functions only call the
* function but wait for it to return instead of running in on another
- * thread, and the mutices do nothing really. The only reason to provide
+ * thread, and the mutexes do nothing really. The only reason to provide
* such a function is that the program can be compiled both in MT and non-MT
* mode without difference.
*
VECTOR &y) = 0;
/**
- * Empty structure used to store informations.
+ * Empty structure used to store information.
*/
struct Status {};
* and reports how much time we spent there. Moreover, the class measures the
* total time spent from start to termination of the TimerOutput object. In
* this case, we did a lot of other stuff, so that the time proportions of the
- * functions we measured are far away from 100 precent.
+ * functions we measured are far away from 100 percent.
*
*
* <h3>Using scoped timers</h3>
/**
* Invalid manifold_id which we need in several places as a default value.
* We assume that all valid manifold_ids lie in the range [0,
- * invalid_maifold_id).
+ * invalid_manifold_id).
*
* @see
* @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
* deal.II classes, by default spacedim is equal to dimension, the above
* string is usually contracted to "<dim>", instead of "<dim,spacedim>".
* This function returns a string containing "dim" if dim is equal to
- * spacedim, otherwhise it returns "dim,spacedim".
+ * spacedim, otherwise it returns "dim,spacedim".
*/
std::string dim_string(const int dim, const int spacedim);
/**
* Read a (signed) integer starting at the position in @p name indicated by
- * the second argument, and retun this integer as a pair together with how
+ * the second argument, and return this integer as a pair together with how
* many characters it takes up in the string.
*
* If no integer can be read at the indicated position, return
// did len
// become==0
// somehow? that
- // shouln't have
+ // shouldn't have
// happened
Assert (false, ExcInternalError());
}
* undefined behavior.
*
* The argument @p add_into selects where the entries should only be written
- * into the output arrays or the result should be added into the exisiting
+ * into the output arrays or the result should be added into the existing
* entries in the output. For <code>add_into == false</code>, the following
* code is assumed:
*
*
* Once an item is processed by the copier, it is deleted and the ScratchData
* and CopyData objects that were used in its computation are considered
- * unused and may be re-used for the next invokation of the worker function,
+ * unused and may be re-used for the next invocation of the worker function,
* on this or another thread.
*
* The functions in this namespace only really work in parallel when
/**
* Constructor. Take an iterator range, the size of a buffer that can
* hold items, and the sample additional data object that will be
- * passed to each worker and copier function invokation.
+ * passed to each worker and copier function invocation.
*/
IteratorRangeToItemStream (const Iterator &begin,
const Iterator &end,
}
}
- // mark current item as useable again
+ // mark current item as usable again
current_item->currently_in_use = false;
* interpolate() or deserialize() you need to supply distributed vectors
* without ghost elements.
*
- * <h3>Transfering a solution</h3> Here VECTOR is your favorite vector
+ * <h3>Transferring a solution</h3> Here VECTOR is your favorite vector
* type, e.g. PETScWrappers::MPI::Vector, TrilinosWrappers::MPI::Vector,
* or corresponding blockvectors.
* @code
* stores the dof indices of each cell and stores the dof values of the
* vectors in @p all_in in each cell that'll be coarsened. @p all_in
* includes all vectors that are to be interpolated onto the new
- * (refined and/or coarsenend) grid.
+ * (refined and/or coarsened) grid.
*/
void prepare_for_coarsening_and_refinement (const std::vector<const VECTOR *> &all_in);
//TODO[WB/MK]: This function could me made more efficient because it
//allocates memory, which could be avoided by passing in another
-//argument as a scratch array. Comment(GK) Do not bother and leva this
+//argument as a scratch array. Comment(GK) Do not bother and leave this
//to ConstraintMatrix or MeshWorker::Assembler
// get indices of dofs
/**
* Store the indices of degrees of freedom on faces in 1D. As these would
- * be vertices, which are treted separately, don't do anything.
+ * be vertices, which are treated separately, don't do anything.
*
* @author Tobias Leicht, 2006
*/
* for dofs are given to the largest cells as well as their bounding lines and
* vertices, with the dofs of more refined cells getting higher numbers.
*
- * This numbering implies very large bandwiths of the resulting matrices and
+ * This numbering implies very large bandwidths of the resulting matrices and
* is thus vastly suboptimal for some solution algorithms. For this reason,
* the DoFRenumbering class offers several algorithms to reorder the dof
* numbering according. See there for a discussion of the implemented
* <h3>User defined renumbering schemes</h3>
*
* The DoFRenumbering class offers a number of renumbering schemes like the
- * Cuthill-McKey scheme. Basically, the function sets up an array in which for
+ * Cuthill-McKee scheme. Basically, the function sets up an array in which for
* each degree of freedom we store the new index this DoF should have after
* renumbering. Using this array, the renumber_dofs() function of the present
* class is called, which actually performs the change from old DoF indices to
* There is a complication if some or all of the shape functions of the
* finite element in use are non-zero in more than one component (in deal.II
* speak: they are non-primitive). In this case, the coupling element
- * correspoding to the first non-zero component is taken and additional ones
- * for this component are ignored.
+ * corresponding to the first non-zero component is taken and additional
+ * ones for this component are ignored.
*
* @todo Not implemented for hp::DoFHandler.
*
* their associated components in the coefficient matrix.
*
* There is one matrix for couplings in a cell and one for the couplings
- * occuring in fluxes.
+ * occurring in fluxes.
*
* @todo Not implemented for hp::DoFHandler.
*/
/**
* Return whether this block mask represents a mask with exactly
- * <code>n</code> blocks. This is true if either it was initilized with a
+ * <code>n</code> blocks. This is true if either it was initialized with a
* vector with exactly <code>n</code> entries of type <code>bool</code> (in
* this case, @p n must equal the result of size()) or if it was initialized
* with an empty vector (or using the default constructor) in which case it
/**
* Return whether this component mask represents a mask with exactly
- * <code>n</code> components. This is true if either it was initilized with
+ * <code>n</code> components. This is true if either it was initialized with
* a vector with exactly <code>n</code> entries of type <code>bool</code>
* (in this case, @p n must equal the result of size()) or if it was
* initialized with an empty vector (or using the default constructor) in
*
* @note This function is implemented in FiniteElement for the case that the
* element has support points. In this case, the resulting coefficients are
- * just the values in the suport points. All other elements must reimplement
+ * just the values in the support points. All other elements must reimplement
* it.
*/
virtual
/**
* Specify the constraints which the dofs on the two sides of a cell
- * interface underly if the line connects two cells of which one is refined
+ * interface underlie if the line connects two cells of which one is refined
* once.
*
* For further details see the general description of the derived class.
* can be in (all combinations of the three bool flags face_orientation,
* face_flip and face_rotation).
*
- * The standard implementation fills this with zeros, i.e. no permuatation
+ * The standard implementation fills this with zeros, i.e. no permutation
* at all. Derived finite element classes have to fill this Table with the
* correct values.
*/
/**
* Number of degrees of freedom in a hexahedron; not including the degrees
- * of freedom on the quadrilaterals, lines and vertices of the hecahedron.
+ * of freedom on the quadrilaterals, lines and vertices of the hexahedron.
*/
const unsigned int dofs_per_hex;
DEAL_II_NAMESPACE_OPEN
-//TODO:[GK] deg+1 is wrong here and should bew fixed after FiniteElementData was cleaned up
+//TODO:[GK] deg+1 is wrong here and should be fixed after FiniteElementData was cleaned up
template <class POLY, int dim, int spacedim>
FE_DGVector<POLY,dim,spacedim>::FE_DGVector (
* the expressions can be simplified to $t=y$ and
* $\phi_1(x,y)=x,\phi_2(x,y)=y$. However, for all other cases, the functions
* $\phi_1(x,y),\phi_2(x,y)$ are not linear any more, and neither is any
- * linear combincation of them. Consequently, the linear functions are not
+ * linear combination of them. Consequently, the linear functions are not
* within the range of the mapped $P_1$ polynomials.
*
* <h3>Visualization of shape functions</h3> In 2d, the shape functions of
* the expressions can be simplified to $t=y$ and
* $\phi_1(x,y)=x,\phi_2(x,y)=y$. However, for all other cases, the functions
* $\phi_1(x,y),\phi_2(x,y)$ are not linear any more, and neither is any
- * linear combincation of them. Consequently, the linear functions are not
+ * linear combination of them. Consequently, the linear functions are not
* within the range of the mapped $P_1$ polynomials.
*
*
* Determine the values that need to be computed on the unit cell to be able
* to compute all values required by <tt>flags</tt>.
*
- * For the purpuse of this function, refer to the documentation in
+ * For the purpose of this function, refer to the documentation in
* FiniteElement.
*
* This class assumes that shape functions of this FiniteElement do
* Determine the values that need to be computed on every cell to be able to
* compute all values required by <tt>flags</tt>.
*
- * For the purpuse of this function, refer to the documentation in
+ * For the purpose of this function, refer to the documentation in
* FiniteElement.
*
* This class assumes that shape functions of this FiniteElement do
* Determine the values that need to be computed on the unit cell to be able
* to compute all values required by <tt>flags</tt>.
*
- * For the purpuse of this function, refer to the documentation in
+ * For the purpose of this function, refer to the documentation in
* FiniteElement.
*
* This class assumes that shape functions of this FiniteElement do
* Determine the values that need to be computed on every cell to be able to
* compute all values required by <tt>flags</tt>.
*
- * For the purpuse of this function, refer to the documentation in
+ * For the purpose of this function, refer to the documentation in
* FiniteElement.
*
* This class assumes that shape functions of this FiniteElement do
* Determine the values that need to be computed on the unit cell to be able
* to compute all values required by <tt>flags</tt>.
*
- * For the purpuse of this function, refer to the documentation in
+ * For the purpose of this function, refer to the documentation in
* FiniteElement.
*
* This class assumes that shape functions of this FiniteElement do
* Determine the values that need to be computed on every cell to be able to
* compute all values required by <tt>flags</tt>.
*
- * For the purpuse of this function, refer to the documentation in
+ * For the purpose of this function, refer to the documentation in
* FiniteElement.
*
* This class assumes that shape functions of this FiniteElement do
* This function constructs a table which fe_q_hierarchical index each
* degree of freedom in the hierarchic numbering would have.
*
- * This function is anologous to the
+ * This function is analogous to the
* FETools::hierarchical_to_lexicographic_numbering() function. However, in
* contrast to the fe_q_hierarchical numbering defined above, the
* lexicographic numbering originates from the tensor products of
* The node values above rely on integrals, which will be computed by
* quadrature rules themselves. The generalized support points are a set of
* points such that this quadrature can be performed with sufficient accuracy.
- * The points needed are thode of QGauss<sub>k+1</sub> on each face as well as
+ * The points needed are those of QGauss<sub>k+1</sub> on each face as well as
* QGauss<sub>k</sub> in the interior of the cell (or none for
* RT<sub>0</sub>).
*
* correspond to the number of columns of @p projection_matrix. The size of
* @p vector_of_tensors_at_nodes must correspond to the number of rows of @p
* vector_of_tensors_at_nodes . The projection matrix @p projection_matrix
- * desribes the projection of scalar data from the quadrature points and can
- * be obtained from the
+ * describes the projection of scalar data from the quadrature points and
+ * can be obtained from the
* FETools::compute_projection_from_quadrature_points_matrix function.
*/
template <int dim>
* The same is true if @p fe1 is a continuous and @p fe2 is a discontinuous
* finite element. For the case that @p fe1 is a discontinuous and @p fe2 is
* a continuous finite element there is no point interpolation defined at
- * the discontinuities. Therefore the meanvalue is taken at the DoF values
+ * the discontinuities. Therefore the mean value is taken at the DoF values
* on the discontinuities.
*
* Note that for continuous elements on grids with hanging nodes (i.e.
//! Transformed quadrature weights
/**
* Compute the quadrature weights on the real cell, i.e. the weights of the
- * quadrature rule multiplied with the determinant of the Jacoian of the
- * transformation from reference to realcell.
+ * quadrature rule multiplied with the determinant of the Jacobian of the
+ * transformation from reference to real cell.
*/
update_JxW_values = 0x0020,
//! Normal vectors
update_jacobians = 0x0080,
//! Gradient of volume element
/**
- * Compute the dervatives of the Jacobian of the transformation.
+ * Compute the derivatives of the Jacobian of the transformation.
*/
update_jacobian_grads = 0x0100,
//! Volume element
* change if one cell is just a translation of the previous). Currently, this
* variable does only recognize a translation and an inverted translation (if
* dim<spacedim). However, this concept makes it easy to add additional
- * staties to be detected in FEValues/FEFaceValues for making use of these
+ * states to be detected in FEValues/FEFaceValues for making use of these
* similarities as well.
*/
namespace CellSimilarity
* A class that contains all data vectors for FEValues, FEFaceValues, and
* FESubfaceValues.
*
+ * This class has been extracted from FEValuesBase to encapsulate in one
+ * place all of the data, independent of the functions that later
+ * access this data in the public interfaces of the FEValues and related
+ * classes. Consequently, this base class is protected in FEValuesBase.
+ *
+ * The second reason is because in FEValuesBase::reinit, we first need to
+ * call Mapping::fill_fe_values() to compute mapping related data, and later
+ * call FiniteElement::fill_fe_values() to compute shape function related
+ * data. In the first step, Mapping::fill_fe_values() gets a pointer to
+ * its own internal data structure and a pointer to the FEValuesData base
+ * object of FEValuesBase, and the mapping then places the computed data
+ * into the data fields that pertain to the mapping below. In the second
+ * step, the finite element receives a pointer to its own internal object,
+ * and to the current object, and from both of these computes the shape
+ * function related information and, again, places it into the current
+ * FEValuesData object.
+ *
* More information can be found on the page on
* @ref UpdateFlagsEssay.
*
* @note The actual data type of the input vector may be either a
* Vector<T>, BlockVector<T>, or one of the sequential PETSc or
* Trilinos vector wrapper classes. It represents a global vector of DoF
- * values associated with the DofHandler object with which this FEValues
+ * values associated with the DoFHandler object with which this FEValues
* object was last initialized. Alternatively, if the vector argument is of
* type IndexSet, then the function is represented as one that is either
* zero or one, depending on whether a DoF index is in the set or not.
* <h4>Mapping of vector fields, differential forms and gradients of vector
* fields</h4>
*
- * The transfomation of vector fields, differential forms
+ * The transformation of vector fields, differential forms
* (gradients/jacobians) and gradients of vector fields between the reference
* cell and the actual grid cell follows the general form
*
*
* <h3>Technical notes</h3>
*
- * A hint to implementators: no function except the two functions @p
+ * A hint to implementors: no function except the two functions @p
* update_once and @p update_each may add any flags.
*
* For more information about the <tt>spacedim</tt> template parameter check
* i-th column of Y is real_vertex[i]. If we split X=[A|b], the least
* square approx is A x_hat+b Classically X = Y * (M^t (M M^t)^{-1}) Let
* K = M^t * (M M^t)^{-1} = [KA Kb] this can be precomputed, and that is
- * exactely what we do. Finally A = Y*KA and b = Y*Kb.
+ * exactly what we do. Finally A = Y*KA and b = Y*Kb.
*/
Point<dim>
transform_real_to_unit_cell_initial_guess (const std::vector<Point<spacedim> > &vertex,
* parallel codes using the PETSc wrapper classes, the type of the vector can
* be specified as template parameter <tt>EulerVectorType</tt> Not specifying
* this template argument in applications using the PETSc vector classes leads
- * to the construction of a copy of the vector which is not acccessible
+ * to the construction of a copy of the vector which is not accessible
* afterwards!
*
* @author Joshua White, 2008
/**
* Constructor.
*
- * @param[in] degree The polynomical degree of the desired $Q_p$ mapping.
+ * @param[in] degree The polynomial degree of the desired $Q_p$ mapping.
* @param[in] euler_dof_handler A DoFHandler object that defines a finite
* element space. This space needs to have at least dim components and the
* first dim components of the space will be considered displacements
* relative to the original positions of the cells of the triangulation.
* @param[in] euler_vector A finite element function in the space defined by
* the second argument. The first dim components of this function will be
- * interpreted as the displacement we use in definining the mapping,
+ * interpreted as the displacement we use in defining the mapping,
* relative to the location of cells of the underlying triangulation.
*/
MappingQEulerian (const unsigned int degree,
/**
- * Filter for iterators that evaluates to true if th level subdomain id of a
- * cell is equal to the current processor id.
+ * Filter for iterators that evaluates to true if the level subdomain id of
+ * a cell is equal to the current processor id.
*
* @ingroup Iterators
*/
* satisfies the predicate if operators ++ or -- are invoked. Intermediate
* iterator values that lie in between but do not satisfy the predicate are
* skipped. It is thus very simple to write loops over a certain class of
- * objects without the need to explicitely write down the condition they have
+ * objects without the need to explicitly write down the condition they have
* to satisfy in each loop iteration. This in particular is helpful if
* functions are called with a pair of iterators denoting a range on which
* they shall act, by choosing a filtered iterator instead of usual ones.
*
* @note This function silently reorders the vertices on the cells to
* lexicographic ordering (see <code>GridReordering::reorder_grid</code>).
- * In other words, if reodering of the vertices does occur, the ordering of
+ * In other words, if reordering of the vertices does occur, the ordering of
* vertices in the array of <code>corners</code> will no longer refer to the
* same triangulation.
*
* this is not the case, you will encounter problems when using the
* triangulation later on.
*
- * All informations about cell manifold_ids and material ids are copied from
+ * All information about cell manifold_ids and material ids are copied from
* one triangulation to the other, and only the boundary manifold_ids and
* boundary_ids are copied over from the faces of @p in_tria to the faces of
* @p out_tria. If you need to specify manifold ids on interior faces, they
*
* In two dimensions, another difficulty occurs, which has to do with the
* sense of a quadrilateral. A quad consists of four lines which have a
- * direction, which is per definitionem as follows:
+ * direction, which is by definition as follows:
* @verbatim
* 3-->--2
* | |
* For this reason, the <tt>read_*</tt> functions of this class that read in
* grids in various input formats call the GridReordering class to bring the
* order of vertices that define the cells into an ordering that satisfies the
- * requiremenets of the Triangulation class. Be sure to read the documentation
+ * requirements of the Triangulation class. Be sure to read the documentation
* of that class if you experience unexpected problems when reading grids
* through this class.
*
/**
* Based on the vertices of the face and #n_boundary_face_points
- * additional points a tensor product mesh (tranformed to the real space)
+ * additional points a tensor product mesh (transformed to the real space)
* of (#n_boundary_face_points+2)<sup>dim-1</sup> points is plotted on
* each boundary face.
*/
bool color_lines_on_user_flag;
/**
- * This is the number of points on a boundary face, that are ploted
+ * This is the number of points on a boundary face, that are plotted
* additionally to the vertices of the face.
*
* This is used if the mapping used is not the standard @p MappingQ1
static std::string default_suffix (const OutputFormat output_format);
/**
- * Default suffix for the default output format selected throuw
+ * Default suffix for the default output format selected through
* ParameterHandler.
*/
std::string default_suffix () const;
* From the examples above, it is obvious that if we encounter a cell that
* cannot be added to the cells which have already been entered, we can not
* usually point to a cell that is the culprit and that must be entered in a
- * different oreintation. Furthermore, even if we knew which cell, there might
+ * different orientation. Furthermore, even if we knew which cell, there might
* be large number of cells that would then cease to fit into the grid and
* which we would have to find a different orientation as well (in the second
* example above, if we rotated cell 1, then we would have to rotate the cells
* structure, where node N has as many children as there are possible
* orientations of node N+1 (in two space dimensions, there are four
* orientations in which each cell can be constructed from its four vertices;
- * for example, if the vertex indicaes are <tt>(0 1 2 3)</tt>, then the four
+ * for example, if the vertex indices are <tt>(0 1 2 3)</tt>, then the four
* possibilities would be <tt>(0 1 2 3)</tt>, <tt>(1 2 3 0)</tt>, <tt>(2 3 0
* 1)</tt>, and <tt>(3 0 1 2)</tt>). When adding one cell after the other, we
* traverse this tree in a depth-first (pre-order) fashion. When we encounter
* @endverbatim
* First a cell is chosen ( (0,1,4,3) in this case). A single side of the cell
* is oriented arbitrarily (3->4). This choice of orientation is then
- * propogated through the mesh, across sides and elements. (0->1), (6->7) and
+ * propagated through the mesh, across sides and elements. (0->1), (6->7) and
* (9->10). The involves edge-hopping and face hopping, giving a path through
* the mesh shown in dots.
* @verbatim
*
* The first such method is based on the observation that if we fail to insert
* one cell with number N, then this may not be due to cell N-1 unless N-1 is
- * a direct neighbor of N. The reason is abvious: the chosen orientation of
+ * a direct neighbor of N. The reason is obvious: the chosen orientation of
* cell M could only affect the possibilities to add cell N if either it were
* a direct neighbor or if there were a sequence of cells that were added
* after M and that connected cells M and N. Clearly, for M=N-1, the latter
* been added already. This would be cell 0. However, we know that the
* orientation of cell 0 can't be important, so we conclude that there is no
* possible way to orient all the lines of the given cells such that they
- * satisfy the requirements if deal.II triangulations. We know that this can't
+ * satisfy the requirements of deal.II triangulations. We know that this can't
* be, so it results in an exception be thrown.
*
* The bottom line of this example is that when we looked at all possible
* positive measure/volume. In the former case, all cells are inverted. It
* does nothing in 1d.
*
- * The invertion of cells might also work when only a subset of all cells
+ * The inversion of cells might also work when only a subset of all cells
* have negative volume. However, grids consisting of a mixture of negative
- * and positiv oriented cells are very likely to be broken. Therefore, an
+ * and positively oriented cells are very likely to be broken. Therefore, an
* exception is thrown, in case cells are not uniformly oriented.
*
* Note, that this function should be called before reorder_cells().
static const int EdgeToNode[4][2];
/**
- * The edges comin into each node, in anti-clockwise order {
+ * The edges common to each node, in anti-clockwise order {
* {3,0},{0,1},{1,2},{2,3} }
*/
static const int NodeToEdge[4][2];
void build_graph (const std::vector<CellData<2> > &inquads);
/**
- * Orient the internal data into deal.II format The orientation algorith
+ * Orient the internal data into deal.II format The orientation algorithm
* is as follows
*
* 1) Find an unoriented quad (A)
*
* 4) if opposite side to (s) of (B) is unoriented orient it
*
- * 5) repeat 3) and 4) until side-hoppong fails (we've reached a
+ * 5) repeat 3) and 4) until side-hopping fails (we've reached a
* boundary) or (s) has already been oriented (we've closed a loop or
* unoriented sides).
*
bool orient_next_unoriented_edge ();
/**
- * Return whether the cell is consistenty oriented at present (i.e. only
- * considering those edges that are already oriented. This is a sanity
- * check that should be called from inside an assert macro.
+ * Return whether the cell is consistently oriented at present (i.e.
+ * only considering those edges that are already oriented. This is
+ * a sanity check that should be called from inside an assert macro.
*/
bool cell_is_consistent (const unsigned int cell_num) const;
const Mapping<dim,spacedim> &mapping = (StaticMappingQ1<dim,spacedim>::mapping));
/**
- * Return the diamater of the smallest active cell of a triangulation. See
+ * Return the diameter of the smallest active cell of a triangulation. See
* step-24 for an example of use of this function.
*/
template <int dim, int spacedim>
minimal_cell_diameter (const Triangulation<dim, spacedim> &triangulation);
/**
- * Return the diamater of the largest active cell of a triangulation.
+ * Return the diameter of the largest active cell of a triangulation.
*/
template <int dim, int spacedim>
double
* DoFs of the first face should be modified prior to constraining to the
* DoFs of the second face. If @p first_vector_components is non empty the
* matrix is interpreted as a rotation matrix that is applied to all vector
- * valued blocks listet in @p first_vector_components of the FESystem. For
+ * valued blocks listed in @p first_vector_components of the FESystem. For
* more details see make_periodicity_constraints() and the glossary
* @ref GlossPeriodicConstraints "glossary entry on periodic conditions".
*
* over. This is a function you'd typically call when there is only one
* active level on your Triangulation.
*
- * The optional parameter @p reset_boundary_ids, indicates wether this
+ * The optional parameter @p reset_boundary_ids, indicates whether this
* function should reset the boundary_ids of the Triangulation to its
* default value 0 after copying its value to the manifold_id. By default,
* boundary_ids are left untouched.
* underlying manifold.
*
* When reading a Triangulation from a supported input format, typical
- * informations that can be stored in a file are boundary conditions for
+ * information that can be stored in a file are boundary conditions for
* boundary faces (which we store in the boundary_id of the faces), material
* types for cells (which we store in the material_id of the cells) and in
* some cases subdomain ids for cells (which we store in the subdomain_id of
* Manifold objects for new points. This function iterates over active cells
* and copies the material_ids to the manifold_ids.
*
- * The optional parameter @p compute_face_ids, indicates wether this
+ * The optional parameter @p compute_face_ids, indicates whether this
* function should also set the manifold_ids of the faces (both for internal
* faces and for faces on the boundary). If set to true, then each face will
* get a manifold_id equal to the minimum of the surrounding manifold_ids,
* Note that this class could in principle be based on the C++
* <tt>std::map<Key,Value></tt> data type. Instead, it uses another data
* format which is more effective both in terms of computing time for access
- * as well as with regard to memory consumpion.
+ * as well as with regard to memory consumption.
*
*
* <h3>Usage</h3>
* unlike almost all other cases in the library, we here interpret the points
* in the quadrature object to be in real space, not on the reference cell.)
*
- * Internaly, the get_new_point() function calls the project_to_manifold()
+ * Internally, the get_new_point() function calls the project_to_manifold()
* function after computing the weighted average of the quadrature points.
* This allows end users to only overload project_to_manifold() for simple
* situations.
* Should a finer control be necessary, then get_new_point() can be
* overloaded.
*
- * FlatManifold is the specialization from which StraigthBoundary is derived,
+ * FlatManifold is the specialization from which StraightBoundary is derived,
* where the project_to_manifold() function is the identity.
*
* @ingroup manifold
* has zero length, then no periodicity is computed in that direction.
* Whenever a function that tries to compute averages is called, an
* exception will be thrown if one of the points which you are using for the
- * average lies outside the periodicity box. The return points are garanteed
- * to lie in the perodicity box plus or minus tolerance*periodicity.norm().
+ * average lies outside the periodicity box. The return points are
+ * guaranteed to lie in the periodicity box plus or minus
+ * tolerance*periodicity.norm().
*/
FlatManifold (const Point<spacedim> periodicity=Point<spacedim>(),
const double tolerance=1e-10);
hex->quad(i)->get_manifold().get_new_point_on_quad(hex->quad(i)));
wp[j] = 1.0/12.0;
}
- // Overwrited the weights with 1/np if we don't want to use
+ // Overwrite the weights with 1/np if we don't want to use
// laplace vectors.
if (with_laplace == false)
std::fill(wp.begin(), wp.end(), 1.0/np);
private:
/**
- * Helper FlatManifold to compute temptative midpoints.
+ * Helper FlatManifold to compute tentative midpoints.
*/
FlatManifold<dim,spacedim> flat_manifold;
* Function<spacedim> and Function<chartdim> objects describing the
* push_forward() and pull_back() functions.
*
- * You can use this Manifold object to describe any arbitray shape domain, as
+ * You can use this Manifold object to describe any arbitrary shape domain, as
* long as you can express it in terms of an invertible map, for which you
* provide both the forward expression, and the inverse expression.
*
- * In debug mode, a check is performed to verify that the tranformations are
+ * In debug mode, a check is performed to verify that the transformations are
* actually one the inverse of the other.
*
* @ingroup manifold
};
/**
- * Manifold identificator of this object. This identificator should be used
+ * Manifold identifier of this object. This identifier should be used
* to identify the manifold to which this object belongs, and from which
* this object will collect information on how to add points upon
* refinement.
* a common number describing the boundary condition to hold on this part of
* the boundary. The triangulation creation function gives lines not in this
* list either the boundary indicator zero (if on the boundary) or
- * numbers::internal_face_boundary_id (if in the interior). Explicitely giving
+ * numbers::internal_face_boundary_id (if in the interior). Explicitly giving
* a line the indicator numbers::internal_face_boundary_id will result in an
* error, as well as giving an interior line a boundary indicator.
*
* For technical reasons, writing and restoring a Triangulation object is not-
* trivial. The primary reason is that unlike many other objects,
* triangulations rely on many other objects to which they store pointers or
- * with which they interace; for example, triangulations store pointers to
+ * with which they interface; for example, triangulations store pointers to
* objects describing boundaries and manifolds, and they have signals that
* store pointers to other objects so they can be notified of changes in the
* triangulation (see the section on signals in this introduction). As objects
* before calling execute_coarsening_and_refinement the first time. The
* easiest way to achieve this is by calling global_refine(1) straight
* after creation of the triangulation. It follows that active cells on
- * level 1 may not be coarsenend.
+ * level 1 may not be coarsened.
*
* The main use of this flag is to ensure that each cell has at least one
* neighbor in each coordinate direction (i.e. each cell has at least a
* left or right, and at least an upper or lower neighbor in 2d). This is
- * a necessary precondition for some algorihms that compute finite
+ * a necessary precondition for some algorithms that compute finite
* differences between cells. The DerivativeApproximation class is one of
* these algorithms that require that a triangulation is coarsest_level_1
* unless all cells already have at least one neighbor in each coordinate
/**
* This flag includes all the above ones and therefore combines all
* smoothing algorithms implemented with the exception of anisotropic
- * smoothening.
+ * smoothing.
*/
maximum_smoothing = 0xffff ^ allow_anisotropic_smoothing
};
/**
* Assign a manifold object to a certain part of the the triangulation. If
- * an object with manfifold number @p number is refined, this object is used
+ * 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
* for non-linear (i.e.: non-Q1) transformations of cells to the unit cell
/**
* Used to store the index of the element presently pointed to on the level
- * presentl used.
+ * presently used.
*/
int present_index;
* direction. @p true indicates, that the line is oriented from vertex 0 to
* vertex 1, whereas it is the other way around otherwise. In 1d and 2d,
* this is always @p true, but in 3d it may be different, see the respective
- * discussion in the documentation of the GeometryInfo classe.
+ * discussion in the documentation of the GeometryInfo class.
*
* This function is really only for internal use in the library unless you
* absolutely know what this is all about.
* If the present cell is not refined, one is returned.
*
* If one considers a triangulation as a forest where the root of each tree
- * are the coarse mesh cells and nodes have descendents (the children of a
+ * are the coarse mesh cells and nodes have descendants (the children of a
* cell), then this function returns the number of terminal nodes in the
* sub-tree originating from the current object; consequently, if the
* current object is not further refined, the answer is one.
/**
* Access the value of the user pointer. It is in the responsibility of the
* user to make sure that the pointer points to something useful. You should
- * use the new style cast operator to maintain a minimum of typesafety, e.g.
+ * use the new style cast operator to maintain a minimum of type safety, e.g.
*
* @note User pointers and user indices are mutually exclusive. Therefore,
* you can only use one of them, unless you call
* Center of the object. The center of an object is defined to be the
* average of the locations of the vertices. If required, the user may ask
* this function to return the average of the point according to the
- * underlyinging Manifold object, by setting to true the optional parameter
- * @p respect_manifold.
+ * underlying Manifold object, by setting to true the optional parameter @p
+ * respect_manifold.
*
* When the geometry of a TriaAccessor is not flat, or when part of the
* bounding objects of this TriaAccessor are not flat, the result given by
*
* This function is only for internal use in the library. Setting this flag
* to any other value than the one that the triangulation has already set is
- * bound to bring you desaster.
+ * bound to bring you disaster.
*/
void set_face_orientation (const unsigned int face,
const bool orientation) const;
Point<spacedim> &vertex (const unsigned int i = 0) const;
/**
- * Return the center of this object, which of course co-incides with the
+ * Return the center of this object, which of course coincides with the
* location of the vertex this object refers to.
*/
Point<spacedim> center () const;
/**
* Set the boundary indicator of this object and all of its lower-
* dimensional sub-objects. Since this object only represents a single
- * vertex, there are no lower-dimensional obejct and this function is
+ * vertex, there are no lower-dimensional object and this function is
* equivalent to calling set_boundary_id() with the same argument.
*
* @ingroup boundary
/**
* Set the manifold indicator of this object and all of its lower-
* dimensional sub-objects. Since this object only represents a single
- * vertex, there are no lower-dimensional obejct and this function is
+ * vertex, there are no lower-dimensional object and this function is
* equivalent to calling set_manifold_id() with the same argument.
*
* @ingroup manifold
* works for parallel triangulations. See the documentation of the CellId
* class for more information.
*
- * @note This operation takes O(level) time to compute. In most practicaly
+ * @note This operation takes O(level) time to compute. In most practical
* cases, the number of levels of a triangulation will depend
* logarithmically on the number of cells in the triangulation.
*/
* neighbor_of_coarser_neighbor() function should be call. If you'd like to
* know only the <code>face_no</code> which is required to get back from the
* neighbor to the present cell then simply use the neighbor_face_no()
- * function which can be used for coarser as well as noncoarser neighbors.
+ * function which can be used for coarser as well as non-coarser neighbors.
*/
unsigned int neighbor_of_neighbor_internal (const unsigned int neighbor) const;
// the quad for its line_orientation. however, if
// the face is rotated, it might be possible,
// that a standard orientation of the line
- // with respect to the face corrsponds to a
+ // with respect to the face corresponds to a
// non-standard orientation for the line with
// respect to the cell.
//
{ { true, true }, // lines 0/1, face_orientation=true, face_flip=false, face_rotation=false and true
{ false, false }
}
- },// linea 0/1, face_orientation=true, face_flip=true, face_rotation=false and true
+ },// lines 0/1, face_orientation=true, face_flip=true, face_rotation=false and true
{ { { true, true }, // lines 2/3 ...
{ false, false }
*/
TorusBoundary (const double R, const double r);
-//Boundary Refinenment Functions
+//Boundary Refinement Functions
/**
* Construct a new point on a line.
*/
* The objects pointed to are accessors, derived from TriaAccessorBase. Which
* kind of accessor is determined by the template argument <em>Accessor</em>.
* These accessors are not so much data structures as they are a collection of
- * functions providing access to the data stored in Tringulation or DoFHandler
+ * functions providing access to the data stored in Triangulation or DoFHandler
* objects. Using these accessors, the structure of these classes is hidden
* from the application program.
*
*
* The iterator class itself does not have much functionality. It only becomes
* useful when assigned an Accessor (the second template parameter), which
- * really does the access to data. An Accessor has to fulfil some
+ * really does the access to data. An Accessor has to fulfill some
* requirements:
*
* <ul>
* set to false.
*
* The last two checks are not made in <tt>state()</tt> since both cases
- * should only occur upon unitialized construction through @p memcpy and the
+ * should only occur upon uninitialized construction through @p memcpy and the
* like (the parent triangulation can only be set upon construction). If an
* iterator is constructed empty through the empty constructor,
* <tt>present_level==-2</tt> and <tt>present_index==-2</tt>. Thus, the
* invalid provides a second track of security: if we should have forgotten a
* check in the library when an iterator is incremented or decremented, we
* automatically convert the iterator from the allowed state "past-the-end" to
- * the disallowed state "invalid" which increases the chance that somehwen
+ * the disallowed state "invalid" which increases the chance that some time
* earlier than for past-the-end iterators an exception is raised.
*
* @ref Triangulation
*
* In fact, we would not need them to be friends if they were for different
* dimensions, but the compiler dislikes giving a fixed dimension and
- * variable accessor since then it says that would be a artial
+ * variable accessor since then it says that would be a partial
* specialization.
*/
template <typename SomeAccessor> friend class TriaRawIterator;
// do this like this, because:
// if we write
// "Assert (IteratorState::past_the_end || !has_children())"
- // has_chidlren() is called anyway, even if
+ // has_children() is called anyway, even if
// state==IteratorState::past_the_end, and will then
// throw the exception!
if (this->state() != IteratorState::past_the_end)
// do this like this, because:
// if we write
// "Assert (IteratorState::past_the_end || !has_children())"
- // has_chidlren() is called anyway, even if
+ // has_children() is called anyway, even if
// state==IteratorState::past_the_end, and will then
// throw the exception!
if (this->state() != IteratorState::past_the_end)
/**
* This class implements some types which differ between the dimensions.
- * These are the declararions for the 3D case only. See the
+ * These are the declarations for the 3D case only. See the
* @ref Iterators
* module for more information.
*
* In one dimension, a neighbor may have any level less or equal the
* level of this cell. If it has the same level, it may be refined an
* arbitrary number of times, but the neighbor pointer still points to
- * the cell on the same level, while the neighbors of the childs of the
- * neighbor may point to this cell or its children.
+ * the cell on the same level, while the neighbors of the children of
+ * the neighbor may point to this cell or its children.
*
* In two and more dimensions, the neighbor is either on the same level
* and refined (in which case its children have neighbor pointers to
/**
* Check the memory consistency of the different containers. Should only
- * be called with the prepro flag @p DEBUG set. The function should be
- * called from the functions of the higher TriaLevel classes.
+ * be called with the preprocessor flag @p DEBUG set. The function
+ * should be called from the functions of the higher TriaLevel classes.
*/
void monitor_memory (const unsigned int true_dimension) const;
/**
* Clear all user pointers or indices and reset their type, such that
- * the next access may be aither or.
+ * the next access may be either or.
*/
void clear_user_data();
/**
* Check the memory consistency of the different containers. Should only
- * be called with the prepro flag @p DEBUG set. The function should be
- * called from the functions of the higher TriaLevel classes.
+ * be called with the preprocessor flag @p DEBUG set. The function
+ * should be called from the functions of the higher TriaLevel classes.
*/
void monitor_memory (const unsigned int true_dimension) const;
};
/**
- * Enum descibing the possible types of userdata.
+ * Enum describing the possible types of userdata.
*/
enum UserDataType
{
/**
* For edges, we enforce a standard convention that opposite edges
- * should be parallel. Now, that's enforcable in most cases, and we have
- * code that makes sure that if a mesh allows this to happen, that we
- * have this convention. We also know that it is always possible to have
- * opposite faces have parallel normal vectors. (For both things, see
- * the Agelek, Anderson, Bangerth, Barth paper mentioned in the
+ * should be parallel. Now, that's enforceable in most cases, and we
+ * have code that makes sure that if a mesh allows this to happen, that
+ * we have this convention. We also know that it is always possible to
+ * have opposite faces have parallel normal vectors. (For both things,
+ * see the Agelek, Anderson, Bangerth, Barth paper mentioned in the
* publications list.)
*
* The problem is that we originally had another condition, namely that
/**
* Check the memory consistency of the different containers. Should only
- * be called with the prepro flag @p DEBUG set. The function should be
- * called from the functions of the higher TriaLevel classes.
+ * be called with the preprocessor flag @p DEBUG set. The function
+ * should be called from the functions of the higher TriaLevel classes.
*/
void monitor_memory (const unsigned int true_dimension) const;
/**
* Check the memory consistency of the different containers. Should only
- * be called with the prepro flag @p DEBUG set. The function should be
- * called from the functions of the higher TriaLevel classes.
+ * be called with the preprocessor flag @p DEBUG set. The function
+ * should be called from the functions of the higher TriaLevel classes.
*/
void monitor_memory (const unsigned int true_dimension) const;
* cells, as this information is 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,
+ * on degrees of freedom located on quads and lines. In 1D we do nothing,
* as the faces of lines are vertices which are treated separately.
*
* Apart from the internal::hp::DoFObjects object containing the data to
* object.
*
* This function is made virtual, since a dof handler object might be
- * accessed through a pointers to thisr base class, although the actual
+ * accessed through a pointers to this base class, although the actual
* object might be a derived class.
*/
virtual std::size_t memory_consumption () const;
/**
* Return the maximum number of quadrature points over all the elements of
* the collection. This is mostly useful to initialize arrays to allocate
- * the maxmimum amount of memory that may be used when re-sizing later on
+ * the maximum amount of memory that may be used when re-sizing later on
* to a articular quadrature formula from within this collection.
*/
unsigned int max_n_quadrature_points () const;
* |
* op_a10 | op_a11
* @endcode
- * The coresponding block_operator invocation takes the form
+ * The corresponding block_operator invocation takes the form
* @code
* block_operator<2, 2, BlockVector<double>>({op_a00, op_a01, op_a10, op_a11});
* @endcode
*
* The list @p ops is best passed as an initializer list. Consider for example
* a linear operator block (acting on Vector<double>) <code>diag(op_a0, op_a1,
- * ..., op_am)</code>. The coresponding block_operator invocation takes the
+ * ..., op_am)</code>. The corresponding block_operator invocation takes the
* form
* @code
* block_diagonal_operator<m, BlockVector<double>>({op_00, op_a1, ..., op_am});
* block triangular matrix.
* As argument, it takes an array of array of LinearOperators @p block_matrix
* representing a lower block triangular matrix and an array of LinearOperators
- * @p inverse_diagonal representing inverses of digonal blocks of @p block_matrix.
+ * @p inverse_diagonal representing inverses of diagonal blocks of @p block_matrix.
*
* Let us assume we have a linear system with the following block structure:
*
* block triangular matrix.
* As argument, it takes an array of array of LinearOperators @p block_matrix
* representing an upper block triangular matrix and an array of LinearOperators
- * @p inverse_diagonal representing inverses of digonal blocks of @p block_matrix.
+ * @p inverse_diagonal representing inverses of diagonal blocks of @p block_matrix.
*
* Let us assume we have a linear system with the following block structure:
*
* block_forward_substitution to invert triangular matrices. It takes as input
* a triangular block matrix @p block_matrix, an array of LinearOperators @p
* inverse_diagonal representing inverses of block_matrix, and an optional
- * bool @p lower used to specify if block_matrix should be conidered as lower
+ * bool @p lower used to specify if block_matrix should be considered as lower
* triangular matrix (true) or as upper triangular matrix (false). @p lower is
* equal to true by default.
*
const size_type col);
/**
- * Initalize const accessor from non const accessor.
+ * Initialize const accessor from non const accessor.
*/
Accessor(const Accessor<BlockMatrix, false> &);
* Copy the given matrix to this one. The operation throws an error if the
* sparsity patterns of the two involved matrices do not point to the same
* object, since in this case the copy operation is cheaper. Since this
- * operation is notheless not for free, we do not make it available through
+ * operation is nonetheless not for free, we do not make it available through
* operator=(), since this may lead to unwanted usage, e.g. in copy
* arguments to functions, which should really be arguments by reference.
*
* Print the matrix to the given stream, using the format <tt>(line,col)
* value</tt>, i.e. one nonzero entry of the matrix per line. The optional
* flag outputs the sparsity pattern in a different style according to the
- * underlying sparsematrix type.
+ * underlying sparse matrix type.
*/
void print (std::ostream &out,
const bool alternative_output = false) const;
typedef typename BaseClass::const_iterator const_iterator;
/**
- * @name Constructors and initalization
+ * @name Constructors and initialization
*/
//@{
/**
/**
* Resize the matrix, by setting the number of block rows and columns. This
- * deletes all blocks and replaces them by unitialized ones, i.e. ones for
- * which also the sizes are not yet set. You have to do that by calling the
- * reinit() functions of the blocks themselves. Do not forget to call
+ * deletes all blocks and replaces them with uninitialized ones, i.e. ones
+ * for which also the sizes are not yet set. You have to do that by calling
+ * the reinit() functions of the blocks themselves. Do not forget to call
* collect_sizes() after that on this object.
*
* The reason that you have to set sizes of the blocks yourself is that the
/**
* Update internal structures after resizing vectors. Whenever you reinited
* a block of a block vector, the internal data structures are corrupted.
- * Therefore, you should call this function after al blocks got their new
+ * Therefore, you should call this function after all blocks got their new
* size.
*/
void collect_sizes ();
/**
- * A collective add operation: This funnction adds a whole set of values
+ * A collective add operation: This function adds a whole set of values
* stored in @p values to the vector components specified by @p indices.
*/
template <typename Number>
};
/**
- * @name Constructors and initalization.
+ * @name Constructors and initialization.
*/
//@{
/**
* Copy the given matrix to this one. The operation throws an error if the
* sparsity patterns of the two involved matrices do not point to the same
* object, since in this case the copy operation is cheaper. Since this
- * operation is notheless not for free, we do not make it available through
+ * operation is nonetheless not for free, we do not make it available through
* <tt>operator =</tt>, since this may lead to unwanted usage, e.g. in copy
* arguments to functions, which should really be arguments by reference.
*
/**
* Allocated size of #val. This can be larger than the actually used part if
- * the size of the matrix was reduced somewhen in the past by associating a
+ * the size of the matrix was reduced sometime in the past by associating a
* sparsity pattern with a smaller size to this object, using the reinit()
* function.
*/
const std::vector<std::pair<size_type,double> > &col_val_pairs);
/**
- * Set an imhomogeneity to the constraint line <i>i</i>, according to the
+ * Set an inhomogeneity to the constraint line <i>i</i>, according to the
* discussion in the general class description.
*
* @note the line needs to be added with one of the add_line() calls first.
/**
* Close the filling of entries. Since the lines of a matrix of this type
* are usually filled in an arbitrary order and since we do not want to use
- * associative constainers to store the lines, we need to sort the lines and
+ * associative constrainers to store the lines, we need to sort the lines and
* within the lines the columns before usage of the matrix. This is done
* through this function.
*
/**
* Returns <tt>true</tt> in case the dof is constrained and there is a non-
- * trivial inhomogeneous valeus set to the dof.
+ * trivial inhomogeneous values set to the dof.
*/
bool is_inhomogeneously_constrained (const size_type index) const;
* entries takes place when calling the <tt>close()</tt> function.
*
* We could, instead of using a vector, use an associative array, like a map
- * to store the lines. This, however, would mean a much more fractioned heap
+ * to store the lines. This, however, would mean a much more fragmented heap
* since it allocates many small objects, and would additionally make usage
* of this matrix much slower.
*/
}
-//TODO: I'm sure the followng could be made more elegant by using a bit of
+//TODO: I'm sure the following could be made more elegant by using a bit of
//introspection using static member variables of the various vector
//classes to dispatch between the different functions, rather than using
//knowledge of the individual types
// now to the vectors. besides doing the same job as we did above (i.e.,
// distribute the content of the local vector into the global one), need
- // to account for inhomogeneities here: thie corresponds to eliminating
+ // to account for inhomogeneities here: this corresponds to eliminating
// the respective column in the local matrix with value on the right
// hand side.
if (use_vectors == true)
* This class takes as template arguments a matrix and a vector class. The
* former must provide @p vmult, @p vmult_add, @p Tvmult, and @p residual
* member function that operate on the vector type (the second template
- * argument). The latter template parameter must provide access to indivual
+ * argument). The latter template parameter must provide access to individual
* elements through <tt>operator()</tt>, assignment through
* <tt>operator=</tt>.
*
/**
* Set the matrix to be used further on. You will probably also want to call
- * the clear_constraints() function if constraits were previously added.
+ * the clear_constraints() function if constraints were previously added.
*
* @arg @p m: The matrix being used in multiplications.
*
*
* We expect this for instance in Newton's method, where the residual
* already should be zero on constrained nodes. This is, because there is no
- * testfunction in these nodes.
+ * test function in these nodes.
*/
bool expect_constrained_source;
#endif
// otherwise do it by hand. use the
- // Gauss-Jordan-Algorithmus from
+ // Gauss-Jordan-Algorithm from
// Stoer & Bulirsch I (4th Edition)
// p. 153
const size_type N = n();
// For all subsequent columns do
- // the Householder reflexion
+ // the Householder reflection
for (size_type k=j+1 ; k<n ; ++k)
{
number2 sum = diagonal[j]*this->el(j,k);
{
public:
/**
- * Declate type for container size.
+ * Declare type for container size.
*/
typedef types::global_dof_index size_type;
/**
* The solver, which allows selection of the actual solver as well as
- * adjuxtment of parameters.
+ * adjustment of parameters.
*/
SolverSelector<VECTOR> solver;
* instance in MGLevelObject without extracting the #matrix first.
*
* MatrixBlock comes handy when using BlockMatrixArray. Once the MatrixBlock
- * has been properly initalized and filled, it can be used in the simplest
+ * has been properly initialized and filled, it can be used in the simplest
* case as:
* @code
* MatrixBlockVector<SparseMatrix<double> > > blocks;
/**
* Set several elements in the specified row of the matrix with column
* indices as given by <tt>col_indices</tt> to the respective value. This is
- * the function doing thye actual work for the ones adding full matrices.
+ * the function doing the actual work for the ones adding full matrices.
* The global locations <tt>row_index</tt> and <tt>col_indices</tt> are
* translated into locations in this block and ExcBlockIndexMismatch is
* thrown, if the global index does not point into the block referred to by
private:
/**
- * The rwo BlockIndices of the whole system. Using row(), this allows us to
+ * The row BlockIndices of the whole system. Using row(), this allows us to
* find the index of the first row degree of freedom for this block.
*/
BlockIndices row_indices;
*
* Since often only clearing of the individual matrices is desired, but not
* removing the blocks themselves, there is an optional argument. If the
- * argument is missing or @p false, all matrices will be mepty, but the size
+ * argument is missing or @p false, all matrices will be empty, but the size
* of this object and the block positions will not change. If @p
* really_clean is @p true, then the object will contain no blocks at the
* end.
*
* Since often only clearing of the individual matrices is desired, but not
* removing the blocks themselves, there is an optional argument. If the
- * argument is missing or @p false, all matrices will be mepty, but the size
+ * argument is missing or @p false, all matrices will be empty, but the size
* of this object and the block positions will not change. If @p
* really_clean is @p true, then the object will contain no blocks at the
* end.
void vmult (VECTOR &w, const VECTOR &v) const;
/**
- * Tranposed matrix-vector product.
+ * Transposed matrix-vector product.
*/
void Tvmult (VECTOR &w, const VECTOR &v) const;
const BlockVector<number> &src) const;
/**
- * Add a soruce to dest, where the mean value in the selected component is
+ * Add a source to dest, where the mean value in the selected component is
* subtracted.
*/
template <typename number>
* residual.apply(y);
* residual.apply_add(y);
* @endcode
- * or until the @p PackagedOperation object is implictly converted:
+ * or until the @p PackagedOperation object is implicitly converted:
* @code
* dealii::Vector<double> y;
* y = residual;
}
/**
- * Subract a constant @p offset (of the @p Range space) from the result of a
+ * Subtract a constant @p offset (of the @p Range space) from the result of a
* PackagedOperation.
*/
PackagedOperation<Range> &operator-=(const Range &offset)
PackagedOperation<Range> return_comp;
// ensure to have valid PackagedOperation objects by catching op by value
- // u is catched by reference
+ // u is caught by reference
return_comp.reinit_vector = [&u](Range &x, bool fast)
{
return_comp.reinit_vector = op.reinit_range_vector;
// ensure to have valid PackagedOperation objects by catching op by value
- // u is catched by reference
+ // u is caught by reference
return_comp.apply = [op, &u](Range &v)
{
return_comp.reinit_vector = op.reinit_domain_vector;
// ensure to have valid PackagedOperation objects by catching op by value
- // u is catched by reference
+ // u is caught by reference
return_comp.apply = [op, &u](Domain &v)
{
return_comp.reinit_vector = op.reinit_range_vector;
// ensure to have valid PackagedOperation objects by catching op by value
- // u is catched by reference
+ // u is caught by reference
return_comp.apply = [op, comp](Domain &v)
{
return_comp.reinit_vector = op.reinit_domain_vector;
// ensure to have valid PackagedOperation objects by catching op by value
- // u is catched by reference
+ // u is caught by reference
return_comp.apply = [op, comp](Domain &v)
{
const MPI_Comm communicator);
/**
- * Same as above but the ghost indicies are assumed to be empty.
+ * Same as above but the ghost indices are assumed to be empty.
*/
BlockVector (const std::vector<IndexSet> &local_ranges,
const MPI_Comm communicator);
Vector<Number> &operator -= (const Vector<Number> &V);
/**
- * A collective add operation: This funnction adds a whole set of values
+ * A collective add operation: This function adds a whole set of values
* stored in @p values to the vector components specified by @p indices.
*/
template <typename OtherNumber>
/**
* Resize the matrix, by setting the number of block rows and columns.
- * This deletes all blocks and replaces them by unitialized ones, i.e.
+ * This deletes all blocks and replaces them by uninitialized ones, i.e.
* ones for which also the sizes are not yet set. You have to do that by
* calling the @p reinit functions of the blocks themselves. Do not forget
* to call collect_sizes() after that on this object.
*
* The interface of this class is modeled after the existing SparseMatrix
* class in deal.II. It has almost the same member functions, and is often
- * exchangable. However, since PETSc only supports a single scalar type
+ * exchangeable. However, since PETSc only supports a single scalar type
* (either double, float, or a complex data type), it is not templated, and
* only works with whatever your PETSc installation has defined the data
* type PetscScalar to.
if (value == PetscScalar())
{
- // we have to do checkings on Insert/Add in any case to be
+ // we have to check after using Insert/Add in any case to be
// consistent with the MPI communication model (see the comments in
// the documentation of TrilinosWrappers::Vector), but we can save
// some work if the addend is zero. However, these actions are done
/**
* Resize the matrix, by setting the number of block rows and columns.
- * This deletes all blocks and replaces them by unitialized ones, i.e.
- * ones for which also the sizes are not yet set. You have to do that by
- * calling the @p reinit functions of the blocks themselves. Do not
- * forget to call collect_sizes() after that on this object.
+ * This deletes all blocks and replaces them with uninitialized ones,
+ * i.e. ones for which also the sizes are not yet set. You have to do
+ * that by calling the @p reinit functions of the blocks themselves. Do
+ * not forget to call collect_sizes() after that on this object.
*
* The reason that you have to set sizes of the blocks yourself is that
* the sizes may be varying, the maximum number of elements per row may
* the collective MPI functions and wait for all the other processes to
* join in on this. Since the other processes don't call this function,
* you will either get a time-out on the first process, or, worse, by the
- * time the next a callto a PETSc function generates an MPI message on the
+ * time the next a call to a PETSc function generates an MPI message on the
* other processes, you will get a cryptic message that only a subset of
* processes attempted a communication. These bugs can be very hard to
* figure out, unless you are well-acquainted with the communication model
const size_type local_size);
/**
- * Constructs a new parallel ghosted PETSc vector from an Indexset. Note
+ * Constructs a new parallel ghosted PETSc vector from an IndexSet. Note
* that @p local must be contiguous and the global size of the vector is
* determined by local.size(). The global indices in @p ghost are
* supplied as ghost indices that can also be read locally.
/**
* Set this flag to true if you have a symmetric system matrix and you
- * want to use a solver which asumes a symmetric preconditioner like CG.
- * The relaxation is done with SSOR/Jacobi when set to true and with
- * SOR/Jacobi otherwise.
+ * want to use a solver which assumes a symmetric preconditioner like
+ * CG. The relaxation is done with SSOR/Jacobi when set to true and
+ * with SOR/Jacobi otherwise.
*/
bool symmetric_operator;
* Despite the fact that it would seem to be an obvious win, setting the
* @p preset_nonzero_locations flag to @p true doesn't seem to accelerate
* program. Rather on the contrary, it seems to be able to slow down
- * entire programs somewhat. This is suprising, since we can use efficient
+ * entire programs somewhat. This is surprising, since we can use efficient
* function calls into PETSc that allow to create multiple entries at
* once; nevertheless, given the fact that it is inefficient, the
* respective flag has a default value equal to @p false.
*
* The interface of this class is modeled after the existing Vector class in
* deal.II. It has almost the same member functions, and is often
- * exchangable. However, since PETSc only supports a single scalar type
+ * exchangeable. However, since PETSc only supports a single scalar type
* (either double, float, or a complex data type), it is not templated, and
* only works with whatever your PETSc installation has defined the data
* type @p PetscScalar to.
/**
* A collective piecewise multiply operation on <code>this</code> vector
- * with itself. TODO: The model for this function should be similer to add
+ * with itself. TODO: The model for this function should be similar to add
* ().
*
* This function is deprecated.
/**
* Denotes if this vector has ghost indices associated with it. This means
- * that at least one of the processes in a parallel programm has at least
+ * that at least one of the processes in a parallel program has at least
* one ghost index.
*/
bool ghosted;
* matrices. This preconditioner is similar to a Jacobi preconditioner if the
* degree variable is set to one, otherwise some higher order polynomial
* corrections are used. This preconditioner needs access to the diagonal of
- * the matrix its acts on and needs a respective <tt>vmult</tt> implemention.
- * However, it does not need to explicitly know the matrix entries.
+ * the matrix it acts on and needs a respective <tt>vmult</tt>
+ * implementation. However, it does not need to explicitly know the matrix
+ * entries.
*
* This class is useful e.g. in multigrid smoother objects, since it is
* trivially %parallel (assuming that matrix-vector products are %parallel).
protected:
/**
* Initialize matrix and block size for permuted preconditioning.
- * Additionally to the parameters of the other initalize() function, we hand
+ * Additionally to the parameters of the other initialize() function, we hand
* over two index vectors with the permutation and its inverse. For the
* meaning of these vectors see PreconditionBlockSOR.
*
* Perform one block relaxation step in forward numbering.
*
* Depending on the arguments @p dst and @p pref, this performs an SOR step
- * (both reference the same vector) of a Jacobi step (botha different
+ * (both reference the same vector) of a Jacobi step (both different
* vectors). For the Jacobi step, the calling function must copy @p dst to
* @p pref after this.
*
* Perform one block relaxation step in backward numbering.
*
* Depending on the arguments @p dst and @p pref, this performs an SOR step
- * (both reference the same vector) of a Jacobi step (botha different
+ * (both reference the same vector) of a Jacobi step (both different
* vectors). For the Jacobi step, the calling function must copy @p dst to
* @p pref after this.
*
a_block = row / bs;
// This is the end accessor, which
- // does not hava a valid block.
+ // does not have a valid block.
if (a_block == matrix->size())
return;
// numbering of the unknowns in the
// blocks.
// row, column are the global numbering
- // of the unkowns.
+ // of the unknowns.
M_cell = 0;
for (unsigned int cell=0; cell<this->size(); ++cell)
// numbering of the unknowns in the
// blocks.
// row, column are the global numbering
- // of the unkowns.
+ // of the unknowns.
size_type row, row_cell;
number2 b_cell_row;
// The diagonal block if the
// numbering of the unknowns in the
// blocks.
// row, column are the global numbering
- // of the unkowns.
+ // of the unknowns.
size_type row, row_cell;
number2 b_cell_row;
// numbering of the unknowns in the
// blocks.
// row, column are the global numbering
- // of the unkowns.
+ // of the unknowns.
size_type row, row_cell, begin_diag_block=0;
if (!this->inverses_ready())
// numbering of the unknowns in the
// blocks.
// row, column are the global numbering
- // of the unkowns.
+ // of the unknowns.
size_type row, row_cell, block_start=0;
number2 b_cell_row;
// The diagonal block if the
// numbering of the unknowns in the
// blocks.
// row, column are the global numbering
- // of the unkowns.
+ // of the unknowns.
size_type row, row_cell;
size_type block_end=this->blocksize * this->size();
number2 b_cell_row;
* stored. It is then used for all other blocks.
*
* \note Avoid setting this true if your blocks are not equal, in
- * particularr if their sizes differ.
+ * particular if their sizes differ.
*/
bool same_diagonal;
/**
* Pointer to the matrix. Make sure that the matrix exists as long as this
* class needs it, i.e. until calling @p invert_diagblocks, or (if the
* inverse matrices should not be stored) until the last call of the
- * preconditoining @p vmult function of the derived classes.
+ * preconditioning @p vmult function of the derived classes.
*/
SmartPointer<const MATRIX,RelaxationBlock<MATRIX,inverse_type> > A;
* @author Toby D. Young 2008, 2009, 2010, 2011, 2013; and Rickard Armiento
* 2008.
*
- * @note Various tweaks and enhancments contributed by Eloy Romero and Jose E.
- * Roman 2009, 2010.
+ * @note Various tweaks and enhancements contributed by Eloy Romero and Jose
+ * E. Roman 2009, 2010.
*/
namespace SLEPcWrappers
{
/**
* Function that takes a Spectral Transformation context object, and sets
- * the type of spectral transformationthat is appropriate for this class.
+ * the type of spectral transformation that is appropriate for this class.
*/
virtual void set_transformation_type (ST &st) const;
};
/**
* Function that takes a Spectral Transformation context object, and sets
- * the type of spectral transformationthat is appropriate for this class.
+ * the type of spectral transformation that is appropriate for this class.
*/
virtual void set_transformation_type (ST &st) const;
};
/**
* Function that takes a Spectral Transformation context object, and sets
- * the type of spectral transformationthat is appropriate for this class.
+ * the type of spectral transformation that is appropriate for this class.
*/
virtual void set_transformation_type (ST &st) const;
};
/**
* Function that takes a Spectral Transformation context object, and sets
- * the type of spectral transformationthat is appropriate for this class.
+ * the type of spectral transformation that is appropriate for this class.
*/
virtual void set_transformation_type (ST &st) const;
};
* This is useful in cases where you don't want to solve exactly, but rather
* want to gain two digits or if the maximal number of iterations is achieved.
* For example: The maximal number of iterations is 20, the reduction factor
- * is 1% und the tolerance is 0.1%. The initial residual is 2.5. The process
- * will break if 20 iteration are comleted or the new residual is less then
+ * is 1% and the tolerance is 0.1%. The initial residual is 2.5. The process
+ * will break if 20 iteration are completed or the new residual is less then
* 2.5*1% or if it is less then 0.1%.
*
* @author Guido Kanschat
*u[1] -= *m[0];
// Precondition is applied.
// The preconditioner has to be
- // positiv definite and symmetric
+ // positive definite and symmetric
// M v = u[1]
precondition.vmult (v,*u[1]);
*m[0] = v;
// precondition: solve M v = u[2]
- // Preconditioner has to be positiv
+ // Preconditioner has to be positive
// definite and symmetric.
precondition.vmult(v,*u[2]);
/**
* Solve the system $Ax = b$ using the relaxation method $x_{k+1} =
- * R(x_k,b)$. The amtrix <i>A</i> itself is only used to compute the
+ * R(x_k,b)$. The matrix <i>A</i> itself is only used to compute the
* residual.
*/
template<class MATRIX, class RELAXATION>
*
* This matrix class implements the usual interface of preconditioners, that
* is a function initialize(const SparseMatrix<double>&matrix,const
- * AdditionalData) for initalizing and the whole set of vmult() functions
+ * AdditionalData) for initializing and the whole set of vmult() functions
* common to all matrices. Implemented here are only vmult() and vmult_add(),
* which perform multiplication with the inverse matrix. Furthermore, this
* class provides an older interface, consisting of the functions factorize()
typedef types::global_dof_index size_type;
/**
- * Dummy class needed for the usual initalization interface of
+ * Dummy class needed for the usual initialization interface of
* preconditioners.
*/
class AdditionalData
};
/**
- * @name Constructors and initalization
+ * @name Constructors and initialization
*/
//@{
/**
* Copy the given matrix to this one. The operation triggers an assertion
* if the sparsity patterns of the two involved matrices do not point to the
* same object, since in this case the copy operation is cheaper. Since this
- * operation is notheless not for free, we do not make it available through
- * <tt>operator =</tt>, since this may lead to unwanted usage, e.g. in copy
- * arguments to functions, which should really be arguments by reference.
+ * operation is nonetheless not for free, we do not make it available
+ * through <tt>operator =</tt>, since this may lead to unwanted usage,
+ * e.g. in copy arguments to functions, which should really be arguments by
+ * reference.
*
* The source matrix may be a matrix of arbitrary type, as long as its data
* type is convertible to the data type of this matrix.
/**
* Allocated size of #val. This can be larger than the actually used part if
- * the size of the matrix was reduced somewhen in the past by associating a
+ * the size of the matrix was reduced sometime in the past by associating a
* sparsity pattern with a smaller size to this object, using the reinit()
* function.
*/
typedef number value_type;
/**
- * @name Constructors and initalization
+ * @name Constructors and initialization
*/
//@{
/**
* Copy the given matrix to this one. The operation throws an error if the
* sparsity patterns of the two involved matrices do not point to the same
* object, since in this case the copy operation is cheaper. Since this
- * operation is notheless not for free, we do not make it available through
+ * operation is nonetheless not for free, we do not make it available through
* <tt>operator =</tt>, since this may lead to unwanted usage, e.g. in copy
* arguments to functions, which should really be arguments by reference.
*
width = precision+2;
}
- // TODO: Skip nonexisting entries
+ // TODO: Skip nonexistant entries
for (size_type i=0; i<m(); ++i)
{
for (size_type j=0; j<n(); ++j)
/**
* Point-wise Vanka preconditioning. This class does Vanka preconditioning on
* a point-wise base. Vanka preconditioners are used for saddle point problems
- * like Stoke's problem or problems arising in optimization where Lagrange
- * multiplier occur and let Netwon's matrix have a zero block. With these
+ * like Stokes' problem or problems arising in optimization where Lagrange
+ * multipliers occur and the Newton method matrix has a zero block. With these
* matrices the application of Jacobi or Gauss-Seidel methods is impossible,
* because some diagonal elements are zero in the rows of the Lagrange
* multiplier. The approach of Vanka is to solve a small (usually indefinite)
{
public:
/**
- * Declate type for container size.
+ * Declare type for container size.
*/
typedef types::global_dof_index size_type;
// SparsityPattern object
//
// since we do not explicitly
- // consider nonsysmmetric sparsity
+ // consider nonsymmetric sparsity
// patterns, the first element
// of each entry simply denotes
// all degrees of freedom that
#ifdef DEAL_II_WITH_MPI
/**
- * Communciate rows in a compressed sparsity pattern over MPI.
+ * Communicate rows in a compressed sparsity pattern over MPI.
*
* @param dsp is the sparsity pattern that has been built locally and for
* which we need to exchange entries with other processors to make sure that
* in multithread mode, it spawns another thread that reads the data in
* parallel to the usual execution of the program, such that when @p reload
* is called, the data may eventually be available already. It might
- * therefore be wirthwhile to call this function some time in advance, if
+ * therefore be worthwhile to call this function some time in advance, if
* you know that the data will be needed, and loading takes some time, for
* instance if the file to which the data was written is not in a local tmp
* directory.
const VECTOR &src) const;
/**
- * Tranposed matrix-vector product.
+ * Transposed matrix-vector product.
*/
virtual void Tvmult (VECTOR &dst,
const VECTOR &src) const;
const VECTOR &src) const;
/**
- * Tranposed matrix-vector product, adding to <tt>dst</tt>.
+ * Transposed matrix-vector product, adding to <tt>dst</tt>.
*/
virtual void Tvmult_add (VECTOR &dst,
const VECTOR &src) const;
typedef types::global_dof_index size_type;
/**
- * @name Constructors and initalization.
+ * @name Constructors and initialization.
*/
/**
* Constructor generating an empty matrix of dimension <tt>n</tt>.
/**
* Resize the matrix, by setting the number of block rows and columns.
- * This deletes all blocks and replaces them by unitialized ones, i.e.
+ * This deletes all blocks and replaces them with uninitialized ones, i.e.
* ones for which also the sizes are not yet set. You have to do that by
* calling the @p reinit functions of the blocks themselves. Do not forget
* to call collect_sizes() after that on this object.
* <li> @p ilu_fill: This specifies the amount of additional fill-in
* elements besides the original sparse matrix structure. If $k$ is @p
* fill, the sparsity pattern of $A^{k+1}$ is used for the storage of the
- * result of the Gaussian elemination. This is known as ILU($k$) in the
+ * result of the Gaussian elimination. This is known as ILU($k$) in the
* literature. When @p fill is large, the preconditioner comes closer to
* a (direct) sparse LU decomposition. Note, however, that this will
* drastically increase the memory requirement, especially when the
* serial and in parallel, depending on the matrix it is based on. In
* general, an incomplete factorization does not take all fill-in elements
* that would appear in a full factorization (that is the basis for a direct
- * solve). For the ILU-T precondtioner, the parameter <tt>ilut_drop</tt>
+ * solve). For the ILU-T preconditioner, the parameter <tt>ilut_drop</tt>
* lets the user specify which elements should be dropped (i.e., should not
* be part of the incomplete decomposition). Trilinos calculates first the
* complete factorization for one row, and then skips those elements that
* remained the same. What this function does is taking the already
* generated coarsening structure, computing the AMG prolongation and
* restriction according to a smoothed aggregation strategy and then
- * building the whole multilevel hiearchy. This function can be
+ * building the whole multilevel hierarchy. This function can be
* considerably faster than the initialize function, since the coarsening
* pattern is usually the most difficult thing to do when setting up the
* AMG ML preconditioner.
*
* The interface of this class is modeled after the existing SparseMatrix
* class in deal.II. It has almost the same member functions, and is often
- * exchangable. However, since Trilinos only supports a single scalar type
+ * exchangeable. However, since Trilinos only supports a single scalar type
* (double), it is not templated, and only works with doubles.
*
* Note that Trilinos only guarantees that operations do what you expect if
* meant for use in serial programs, where there is no need to specify how
* the matrix is going to be distributed among different processors. This
* function works in %parallel, too, but it is recommended to manually
- * specify the %parallel partioning of the matrix using an Epetra_Map.
+ * specify the %parallel partitioning of the matrix using an Epetra_Map.
* When run in %parallel, it is currently necessary that each processor
* holds the sparsity_pattern structure because each processor sets its
* rows.
* programs following the style of the tutorial programs, this function
* (and the respective call for a rectangular matrix) are the natural way
* to initialize the matrix size, its distribution among the MPI processes
- * (if run in %parallel) as well as the locatoin of non-zero elements.
+ * (if run in %parallel) as well as the location of non-zero elements.
* Trilinos stores the sparsity pattern internally, so it won't be needed
* any more after this call, in contrast to the deal.II own object. The
* optional argument @p exchange_data can be used for reinitialization
* programs, this function (and the respective call for a rectangular
* matrix) are the natural way to initialize the matrix size, its
* distribution among the MPI processes (if run in %parallel) as well as
- * the locatoin of non-zero elements. Trilinos stores the sparsity pattern
+ * the location of non-zero elements. Trilinos stores the sparsity pattern
* internally, so it won't be needed any more after this call, in contrast
* to the deal.II own object. The optional argument @p exchange_data can
* be used for reinitialization with a sparsity pattern that is not fully
if (value == 0)
{
- // we have to do checkings on Insert/Add in any case to be consistent
+ // we have to check after Insert/Add in any case to be consistent
// with the MPI communication model (see the comments in the
// documentation of TrilinosWrappers::Vector), but we can save some
// work if the addend is zero. However, these actions are done in case
typedef SparsityPatternIterators::Iterator const_iterator;
/**
- * @name Basic constructors and initalization.
+ * @name Basic constructors and initialization.
*/
//@{
/**
* – the processor that owns a certain row always owns all the
* column elements, no matter how far they might be spread out. The second
* Epetra_Map is only used to specify the number of columns and for
- * internal arragements when doing matrix-vector products with vectors
+ * internal arrangements when doing matrix-vector products with vectors
* based on that column map.
*
* The number of columns entries per row is specified by the argument
* columns – the processor that owns a certain row always owns all
* the column elements, no matter how far they might be spread out. The
* second Epetra_Map is only used to specify the number of columns and for
- * internal arragements when doing matrix-vector products with vectors
+ * internal arrangements when doing matrix-vector products with vectors
* based on that column map.
*
* The number of columns entries per row is specified as the maximum
* DoFTools::extract_locally_relevant_dofs). The other constructors
* methods use general Trilinos facilities that allow to add elements to
* arbitrary rows (as done by all the other reinit functions). However,
- * this flexbility come at a cost, the most prominent being that adding
+ * this flexibility come at a cost, the most prominent being that adding
* elements into the same matrix from multiple threads in shared memory is
* not safe whenever MPI is used. For these settings, the current method
* is the one to choose: It will store the off-processor data as an
* – the processor that owns a certain row always owns all the
* column elements, no matter how far they might be spread out. The second
* IndexSet is only used to specify the number of columns and for internal
- * arragements when doing matrix-vector products with vectors based on an
+ * arrangements when doing matrix-vector products with vectors based on an
* EpetraMap based on that IndexSet.
*
* The number of columns entries per row is specified by the argument
* DoFTools::extract_locally_relevant_dofs). Trilinos matrices allow to
* add elements to arbitrary rows (as done by all the other reinit
* functions) and this is what all the other reinit methods do, too.
- * However, this flexbility come at a cost, the most prominent being that
+ * However, this flexibility come at a cost, the most prominent being that
* adding elements into the same matrix from multiple threads in shared
* memory is not safe whenever MPI is used. For these settings, the
* current method is the one to choose: It will store the off-processor
* data as an additional sparsity pattern (that is then passed to the
- * Trilinos matrix via the reinit mehtod) which can be organized in such a
+ * Trilinos matrix via the reinit method) which can be organized in such a
* way that thread-safety can be ensured (as long as the user makes sure
* to never write into the same matrix row simultaneously, of course).
*/
// verify that the size of the data type Trilinos expects matches that the
// iterator points to. we allow for some slippage between signed and
- // unsigned and only compare that they are both eiter 32 or 64 bit. to
+ // unsigned and only compare that they are both either 32 or 64 bit. to
// write this test properly, not that we cannot compare the size of
// '*begin' because 'begin' may be an iterator and '*begin' may be an
// accessor class. consequently, we need to somehow get an actual value
* the collective MPI functions and wait for all the other processes to
* join in on this. Since the other processes don't call this function,
* you will either get a time-out on the first process, or, worse, by the
- * time the next a callto a Trilinos function generates an MPI message on
+ * time the next a call to a Trilinos function generates an MPI message on
* the other processes, you will get a cryptic message that only a subset
* of processes attempted a communication. These bugs can be very hard to
* figure out, unless you are well-acquainted with the communication model
static const bool supports_distributed_data = true;
/**
- * @name Basic constructors and initalization.
+ * @name Basic constructors and initialization.
*/
//@{
/**
*
* The interface of this class is modeled after the existing Vector class in
* deal.II. It has almost the same member functions, and is often
- * exchangable. However, since Trilinos only supports a single scalar type
+ * exchangeable. However, since Trilinos only supports a single scalar type
* (double), it is not templated, and only works with that type.
*
* Note that Trilinos only guarantees that operations do what you expect if
* Output of vector in user-defined format. For complex-valued vectors, the
* format should include specifiers for both the real and imaginary parts.
*
- * This funcion is deprecated.
+ * This function is deprecated.
*/
void print (const char *format = 0) const DEAL_II_DEPRECATED;
}
- // Define the functors neccessary to use SIMD with TBB.
+ // Define the functors necessary to use SIMD with TBB.
template <typename Number>
struct Vectorization_multiply_factor
{
* // The following line should output 4.
* cout << array[1] << endl;
*
- * // If debug mode is on, then the following triggers an execption:
+ * // If debug mode is on, then the following triggers an exception:
* view(6) = 4;
*
* // But notice that no checks are performed, so this is legal but WILL
* VectorView<double> wrong_view(10, array);
*
* // Now no assert will be thrown if you type wrong_view(6), but most
- * // likely a seg fault will occur.
+ * // likely a segfault will occur.
* view(6) = 4;
*
* // Notice that this construction is legal. It will create a copy of
VectorView(const size_type new_size, const Number *ptr);
/**
- * This desctructor will only reset the internal sizes and the internal
+ * This destructor will only reset the internal sizes and the internal
* pointers, but it will NOT clear the memory.
*/
~VectorView();
*
* In the above case, the Vector<double>::reinit method is called, and a NEW
* area of memory is reserved, possibly not starting at the same place as
- * before. Hoever, the VectorView<double> object keeps pointing to the same
+ * before. However, the VectorView<double> object keeps pointing to the same
* old area. After the two reinits, any call to view_of_long_vector(i), with
* i>0 might cause an attempt to access invalid areas of memory, or might
* function properly, depending on whether or not the system was able to
// implementation computed a hash value based on the truncated array (to
// given accuracy around 1e-13) in order to easily detect different
// arrays and then made a fine-grained check when the hash values were
- // equal. this was quite lenghty and now we use a std::map with a
+ // equal. this was quite lengthy and now we use a std::map with a
// user-defined comparator to compare floating point arrays to a
// tolerance 1e-13.
std::pair<typename std::map<std::vector<double>, types::global_dof_index,
const unsigned int q_point);
/**
- * Write a constribution that is tested by the divergence to the field
+ * Write a contribution that is tested by the divergence to the field
* containing the values on quadrature points with component @p q_point.
* Access to the same field as through @p get_gradient. If applied before
* the function @p integrate(...,true) is called, this specifies what is
IntegrationInfo();
/**
- * Copy constructor, creating a clone to be used by WorksTream::run().
+ * Copy constructor, creating a clone to be used by WorkStream::run().
*/
IntegrationInfo(const IntegrationInfo<dim, spacedim> &other);
/// Access to finite elements
/**
- * This access function must be used if the initalize() for a group of
+ * This access function must be used if the initialize() for a group of
* elements was used (with a valid BlockInfo object).
*/
const FEValuesBase<dim, spacedim> &fe_values (const unsigned int i) const;
* component or for some components. The classes MGTransferSelect and
* MGTransferBlock handle these cases.
*
- * MGTransferSelect is used if you use mutligrid (on Vector objects) for a
+ * MGTransferSelect is used if you use multigrid (on Vector objects) for a
* single component, possibly grouped using <tt>mg_target_component</tt>.
*
* The class MGTransferBlock handles the case where your multigrid method
* region covered by cells on level <tt>from_level</tt> is smaller than that
* of level <tt>from_level-1</tt> (local refinement), then some degrees of
* freedom in <tt>dst</tt> are active and will not be altered. For the other
- * degress of freedom, the result of the restriction is added.
+ * degrees of freedom, the result of the restriction is added.
*
* @arg src is a vector with as many elements as there are degrees of
* freedom on the finer level
/**
* For each block of the whole block vector, list to what block of the
* multigrid vector it is mapped. Since depending on #selected, there may be
- * fewer mutlilevel blocks than original blocks, some of the entries may be
+ * fewer multilevel blocks than original blocks, some of the entries may be
* illegal unsigned integers.
*/
//TODO: rename this to mg_block_mask, in the same way as has already been done in MGTransferComponent, and give it type BlockMask
// data appropriately to the output
// vector
- // Note that the level is
- // monotonuosly increasing
+ // Note that the level is increasing monotonically
dst = 0;
for (; level_cell != endc; ++level_cell)
{
// data appropriately to the output
// vector
- // Note that the level is
- // monotonuosly increasing
+ // Note that the level is increasing monotonically
dst = 0;
for (; level_cell != endc; ++level_cell)
{
};
#endif
- // NOTE: The dimension of the array is choosen to 5 to allow the choice
+ // NOTE: The dimension of the array is chosen to 5 to allow the choice
// DataOutBase<deal_II_dimension,deal_II_dimension+1> in general
// Wolfgang supposed that we don't need it in general, but however this
// choice avoids a -Warray-bounds check warning
ExcIndexRange(line_no, 0, GeometryInfo<dim>::lines_per_cell));
// array indicating, which simple refine
- // case cuts a line in dirextion x, y or
+ // case cuts a line in direction x, y or
// z. For example, cut_y and everything
// containing cut_y (cut_xy, cut_yz,
// cut_xyz) cuts lines, which are in y
= prefixes.get_implementation();
// The thread that created this LogStream object should be the first
- // in tbb's enumerable_thread_specific containter.
+ // in tbb's enumerable_thread_specific container.
const tbb::enumerable_thread_specific<std::stack<std::string> >::const_iterator first_elem
= impl.begin();
ExcMessage ("MPI error. You can only start MPI once!"));
int mpi_err, provided;
- // this works likempi_err = MPI_Init (&argc, &argv); but tells MPI that
+ // this works like mpi_err = MPI_Init (&argc, &argv); but tells MPI that
// we might use several threads but never call two MPI functions at the
// same time. For an explanation see on why we do this see
// http://www.open-mpi.org/community/lists/users/2010/03/12244.php
Assert (separator.size() > 0,
ExcMessage ("The separator must have a non-zero length."));
Assert (separator != ":",
- ExcMessage ("The separator can not be a colon ':' sicne that "
+ ExcMessage ("The separator can not be a colon ':' since that "
"is the separator between the two elements of <key:value> pairs"));
}
origins.push_back(Point<2>(0.,singularity[1]));
origins.push_back(singularity);
- // Lexycographical ordering.
+ // Lexicographical ordering.
double eps = 1e-8;
unsigned int q_id = 0; // Current quad point index.
const unsigned int DoFHandler<dim,spacedim>::default_fe_index;
-// reference the invalid_dof_index variable explicitely to work around
+// reference the invalid_dof_index variable explicitly to work around
// a bug in the icc8 compiler
namespace internal
{
// then use the algorithm from FullMatrix::gauss_jordan on this
// matrix to find out whether it is singular. the algorithm there
- // does piviting and at the end swaps rows back into their proper
+ // does pivoting and at the end swaps rows back into their proper
// order -- we omit this step here, since we don't care about the
// inverse matrix, all we care about is whether the matrix is
// regular or singular
base_to_block_indices.reinit(1,1);
// initialize the restriction and prolongation matrices. the default
- // contructur of FullMatrix<dim> initializes them with size zero
+ // constructor of FullMatrix<dim> initializes them with size zero
prolongation.resize(RefinementCase<dim>::isotropic_refinement);
restriction.resize(RefinementCase<dim>::isotropic_refinement);
for (unsigned int ref=RefinementCase<dim>::cut_x;
// component index
// of the n-th
// nonzero
- // compoment
+ // component
unsigned int component=0;
for (unsigned int nonzero_comp=0; component<this->n_components();
++component)
for (unsigned int sub=0; sub<GeometryInfo<dim>::max_children_per_face; ++sub)
{
- // The weight fuctions for
+ // The weight functions for
// the coarse face are
// evaluated on the subface
// only.
// when building the shape
// functions, these weights
// are equal to the
- // corresponding shpe
+ // corresponding shape
// functions.
for (unsigned int k=0; k<n_face_points; ++k)
for (unsigned int i_child = 0; i_child < this->dofs_per_cell; ++i_child)
}
Assert(current == npoints, ExcInternalError());
- // Finaly, compute the values of
- // the test functios in the
+ // Finally, compute the values of
+ // the test functions in the
// interior quadrature points
PolynomialsP<dim> poly(deg-2);
data(local,7)=(n-1-j) + i *n - local;
}
- // aditionally initialize reordering of line dofs
+ // additionally initialize reordering of line dofs
for (unsigned int i=0; i<this->dofs_per_line; ++i)
this->adjust_line_dof_index_for_line_orientation_table[i]=this->dofs_per_line-1-i - i;
}
// TODO: The dofs_subcell shall differ by a factor 2^p due to shape functions
// defined on [0,1] instead of [-1,1]. However, that does not seem to be
- // the case. Perhaps this factor is added later on in auxilary functions which
+ // the case. Perhaps this factor is added later on in auxiliary functions which
// use these matrices.
// dofs_cells[0](j,k):
// First this->dofs_per_face DoFs of the constrained
// element are made equal to the current (dominating)
// element, which corresponds to 1 on diagonal of the matrix.
- // DoFs which correspond to higher polynomes
+ // DoFs which correspond to higher polynomials
// are zeroed (zero rows in the matrix).
for (unsigned int i = 0; i < this->dofs_per_face; ++i)
interpolation_matrix (i, i) = 1;
// This function is the same Raviart-Thomas interpolation performed by
// interpolate. Still, we cannot use interpolate, since it was written
-// for smooth functions. Thefunctions interpolated here are not
+// for smooth functions. The functions interpolated here are not
// smooth, maybe even not continuous. Therefore, we must double the
// number of quadrature points in each direction in order to integrate
// only smooth functions.
for (unsigned int sub=0; sub<GeometryInfo<dim>::max_children_per_face; ++sub)
{
- // The weight fuctions for
+ // The weight functions for
// the coarse face are
// evaluated on the subface
// only.
// The following three functions serve to fill the maps from element
// names to elements fe_name_map below. The first one exists because
// we have finite elements which are not implemented for nonzero
- // codimension. These should be transfered to the second function
+ // codimension. These should be transferred to the second function
// eventually.
template <int dim>
// for continuous elements on
// grids with hanging nodes we
// need hanging node
- // constraints. Consequentely,
+ // constraints. Consequently,
// if there are no constraints
// then hanging nodes are not
// allowed.
FE_TraceQ<dim,spacedim>::get_dpo_vector (const unsigned int deg)
{
// This constructs FE_TraceQ in exactly the same way as FE_Q except for the
- // interior degrees of freedom that are not present here (lnine in 1D, quad
+ // interior degrees of freedom that are not present here (line in 1D, quad
// in 2D, hex in 3D).
AssertThrow(deg>0,ExcMessage("FE_TraceQ needs to be of degree > 0."));
std::vector<unsigned int> dpo(dim+1, 1U);
// there is no single nonzero component
//
// the following is not implemented! we need to consider the
- // interplay between mutliple non-zero entries in shape
+ // interplay between multiple non-zero entries in shape
// function and the representation as a symmetric
// second-order tensor
const unsigned int comp =
// quantities are necessary to
// compute what we need. note that
// some flags appear in both
- // conditions and in subsequents
+ // conditions and in subsequent
// set operations. this leads to
// some circular logic. the only
// way to treat this is to
std::vector<Tensor<1,dim> > (n_original_q_points));
if (dim==2)
{
- // ensure a counterclock wise
+ // ensure a counterclockwise
// orientation of tangentials
static const int tangential_orientation[4]= {-1,1,1,-1};
for (unsigned int i=0; i<nfaces; ++i)
}
-// Note that the CellSimilarity flag is modifyable, since MappingFEField can need to
+// Note that the CellSimilarity flag is modifiable, since MappingFEField can need to
// recalculate data even when cells are similar.
template<int dim, int spacedim, class VECTOR, class DH>
CellSimilarity::Similarity
}
-// Note that the CellSimilarity flag is modifyable, since MappingQ can need to
+// Note that the CellSimilarity flag is modifiable, since MappingQ can need to
// recalculate data even when cells are similar.
template<int dim, int spacedim>
CellSimilarity::Similarity
// quantities are necessary to
// compute what we need. note that
// some flags appear in both
- // conditions and in subsequents
+ // conditions and in subsequent
// set operations. this leads to
// some circular logic. the only
// way to treat this is to
std::vector<Tensor<1,dim> > (n_original_q_points));
if (dim==2)
{
- // ensure a counterclock wise
+ // ensure a counterclockwise
// orientation of tangentials
static const int tangential_orientation[4]= {-1,1,1,-1};
for (unsigned int i=0; i<nfaces; ++i)
std::vector<Vector<double> > shift_vector(n_support_pts,Vector<double>(n_components));
// fill shift vector for each support point using an fe_values object. make
- // sure that the fe_values variable isn't used simulatenously from different
+ // sure that the fe_values variable isn't used simultaneously from different
// threads
Threads::Mutex::ScopedLock lock(fe_values_mutex);
fe_values.reinit(dof_cell);
projects / dealii.git / commitdiff