/* ---------------------------------------------------------------------
*
- * Copyright (C) 2000 - 2014 by the deal.II authors
+ * Copyright (C) 2000 - 2015 by the deal.II authors
*
* This file is part of the deal.II library.
*
// @sect4{ElasticProblem::~ElasticProblem}
- // The destuctor is exactly as in step-8.
+ // The destructor is exactly as in step-8.
template <int dim>
ElasticProblem<dim>::~ElasticProblem ()
{
public:
/**
* Constructor, receiving the two operators stored in #op_explicit and
- * #op_implicit. For their meening, see the description of those
+ * #op_implicit. For their meaning, see the description of those
* variables.
*/
ThetaTimestepping (Operator<VECTOR> &op_explicit,
// ---------------------------------------------------------------------
//
-// Copyright (C) 2001 - 2014 by the deal.II authors
+// Copyright (C) 2001 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
* The following example of an user defined function overloads and implements
* only the value() function but not the gradient() function. If the
* gradient() function is invoked then the gradient function implemented by
- * the AutoDerivativeFunction is called, where the latter function imployes
+ * the AutoDerivativeFunction is called, where the latter function employs
* numerical difference quotients.
*
* @code
// ---------------------------------------------------------------------
//
-// Copyright (C) 2013 - 2014 by the deal.II authors
+// Copyright (C) 2013 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
* function is a linear map from ${\mathbb R}^{\text{dim}}$ to ${\mathbb
* R}^{\text{spacedim}}$, the second derivative a bilinear map from ${\mathbb
* R}^{\text{dim}} \times {\mathbb R}^{\text{dim}}$ to ${\mathbb
- * R}^{\text{spacedim}}$ and so on. In deal.II we represent these derivaties
+ * R}^{\text{spacedim}}$ and so on. In deal.II we represent these derivatives
* using objects of type DerivativeForm<1,dim,spacedim,Number>,
* DerivativeForm<2,dim,spacedim,Number> and so on.
* @author Sebastian Pauletti, 2011, Luca Heltai, 2015
// ---------------------------------------------------------------------
//
-// Copyright (C) 1998 - 2014 by the deal.II authors
+// Copyright (C) 1998 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
* The coefficients of these quadrature rules are computed by the function
* described in <a
* href="http://en.wikipedia.org/wiki/Numerical_Recipes">Numerical
- * Recipies</a>.
+ * Recipes</a>.
*
* @author Guido Kanschat, 2001
*/
/**
* @internal Have a class which declares some nested typedefs, depending
* on its template parameters. The general template declares nothing, but
- * there are more useful specializations regaring the last parameter
+ * there are more useful specializations regarding the last parameter
* indicating constness of the table for which accessor objects are to be
* generated in this namespace.
*/
* operator of the <tt>VECTOR</tt> and adds an offset to every index.
*
* Some precautions have to be taken if it is used for a constant vector: the
- * VectorSlice object has to be constant, too. The appropriate initalization
+ * VectorSlice object has to be constant, too. The appropriate initialization
* sequence is like this:
*
* @code
// ---------------------------------------------------------------------
//
-// Copyright (C) 1998 - 2014 by the deal.II authors
+// Copyright (C) 1998 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
* <h3>Generic loops and the third template argument</h3>
*
* Many loops look very similar, whether they operate on the active dofs of
- * the active cells of the Triangulation or on the level dodfs of a single
+ * the active cells of the Triangulation or on the level dofs of a single
* level or the whole grid hierarchy. In order to use polymorphism in such
* loops, they access degrees of freedom through the function
* get_active_or_mg_dof_indices(), which changes behavior according to the
*
* It seems odd at first to declare this typedef inside a class, rather than
* declaring a typedef at global scope. The reason is that C++ does not allow
- * to define templated typedefs, where here in fact we want a typdef that
+ * to define templated typedefs, where here in fact we want a typedef that
* depends on the space dimension. (Defining templated typedefs is something
* that is possible starting with the C++11 standard, but that wasn't possible
* within the C++98 standard in place when this programming pattern was
* mapping from the initial configuration to the current configuration, and a
* reference to the DoFHandler. The most common case is to use the solution
* vector for the problem under consideration as the shift vector. The key
- * reqirement is that the number of components of the given vector field be
+ * requirement is that the number of components of the given vector field be
* equal to (or possibly greater than) the number of space dimensions. If
* there are more components than space dimensions (for example, if one is
* working with a coupled problem where there are additional solution
// ---------------------------------------------------------------------
//
-// Copyright (C) 2003 - 2014 by the deal.II authors
+// Copyright (C) 2003 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
/**
* This class implements some types which differ between the dimensions.
- * These are the declararions for the 1D case only. See the
+ * These are the declarations for the 1D case only. See the
* @ref Iterators
* module for more information.
*
- * A @p line_iterator is typdef'd to an iterator operating on the @p lines
- * member variable of a <tt>Triangulation<1></tt> object. An @p
+ * A @p line_iterator is typedef'd to an iterator operating on the @p
+ * lines member variable of a <tt>Triangulation<1></tt> object. An @p
* active_line_iterator only operates on the active lines. @p
* raw_line_iterator objects operate on all lines, used or not.
*
/**
* This class implements some types which differ between the dimensions.
- * These are the declararions for the 2D case only. See the
+ * These are the declarations for the 2D case only. See the
* @ref Iterators
* module for more information.
*
- * A @p line_iterator is typdef'd to an iterator operating on the @p lines
- * member variable of a <tt>Triangulation<2></tt> object. An @p
+ * A @p line_iterator is typedef'd to an iterator operating on the @p
+ * lines member variable of a <tt>Triangulation<2></tt> object. An @p
* active_line_iterator only operates on the active lines. @p
* raw_line_iterator objects operate on all lines, used or not. Using @p
* active_line_iterators may not be particularly in 2D useful since it
BlockSparseMatrixEZ ();
/**
- * Constructor setting up an object with given unmber of block rows and
+ * Constructor setting up an object with given number of block rows and
* columns. The blocks themselves still have zero dimension.
*/
BlockSparseMatrixEZ (const unsigned int block_rows,
// ---------------------------------------------------------------------
//
-// Copyright (C) 1999 - 2014 by the deal.II authors
+// Copyright (C) 1999 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
/**
- * An implementation of block vectors based on distribued deal.II vectors.
- * While the base class provides for most of the interface, this class
- * handles the actual allocation of vectors and provides functions that
- * are specific to the underlying vector type.
+ * An implementation of block vectors based on distributed deal.II
+ * vectors. While the base class provides for most of the interface, this
+ * class handles the actual allocation of vectors and provides functions
+ * that are specific to the underlying vector type.
*
* @note Instantiations for this template are provided for <tt>@<float@>
* and @<double@></tt>; others can be generated in application programs
// ---------------------------------------------------------------------
//
-// Copyright (C) 2009 - 2014 by the deal.II authors
+// Copyright (C) 2009 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
* eigensolver.solve (A, B, lambda, x, size_of_spectrum);
* @endcode
*
- * @note These options can also be set at the commandline.
+ * @note These options can also be set at the command line.
*
* @ingroup SLEPcWrappers
* @author Toby D. Young 2009, 2013
* <a href="http://www.cise.ufl.edu/research/sparse/umfpack">this link</a>).
* UMFPACK is a set of routines for solving non-symmetric sparse linear
* systems, Ax=b, using the Unsymmetric-pattern MultiFrontal method and direct
- * sparse LU factorization. Matrices may have symmetric or unsymmetrix
+ * sparse LU factorization. Matrices may have symmetric or unsymmetric
* sparsity patterns, and may have unsymmetric entries. The use of this class
* is explained in the
* @ref step_22 "step-22"
/**
- * The transpose of a given matrix. This auxiliary class swaps the effect ov
+ * The transpose of a given matrix. This auxiliary class swaps the effect of
* vmult() and Tvmult() as well as vmult_add() and Tvmult_add().
*
* The implementation is analogous to the class PointerMatrix.
* This class supports two local integration models, corresponding to the
* data models in the documentation of the Assembler namespace. One is the
* standard model suggested by the use of FESystem. Namely, there is one
- * FEValuseBase object in this class, containing all shape functions of the
+ * FEValuesBase object in this class, containing all shape functions of the
* whole system, and having as many components as the system. Using this
* model involves loops over all system shape functions. It requires to
* identify the system components for each shape function and to select the
// ---------------------------------------------------------------------
//
-// Copyright (C) 2006 - 2014 by the deal.II authors
+// Copyright (C) 2006 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
*
* Additionally, since we cannot have a virtual null function, we provide
* flags, which allow us to indicate, whether we want to integrate on
- * boundary and interior faces. Thes flags are true by default, but can be
+ * boundary and interior faces. These flags are true by default, but can be
* modified by applications to speed up the loop.
*
* If a function is not overloaded in a derived class, but its usage flag is
* arguments are the name of the vector and indicators, which information
* is to be extracted from the vector. The name refers to an entry in a
* AnyData object, which will be identified by initialize(). The three
- * bool parameters indicate, whether values, greadients and Hessians of
+ * bool parameters indicate, whether values, gradients and Hessians of
* the finite element function are to be computed on each cell or face.
*/
void add(const std::string &name,
// ---------------------------------------------------------------------
//
-// Copyright (C) 2003 - 2014 by the deal.II authors
+// Copyright (C) 2003 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
{
/**
* Multilevel matrix. This matrix stores an MGLevelObject of
- * PointerMatrixBase objects. It implementes the interface defined in
+ * PointerMatrixBase objects. It implements the interface defined in
* MGMatrixBase, so that it can be used as a matrix in Multigrid.
*
* @author Guido Kanschat
void set_symmetric (const bool);
/**
- * Switch on/off transposed smoothing. The effect is overriden by
+ * Switch on/off transposed smoothing. The effect is overridden by
* set_symmetric().
*/
void set_transpose (const bool);
*
* For the (graphical) output of a FE solution one frequently wants to include
* derived quantities, which are calculated from the values of the solution
- * and possibly the first and second derivates of the solution. Examples are
+ * and possibly the first and second derivatives of the solution. Examples are
* the calculation of Mach numbers from velocity and density in supersonic
* flow computations, or the computation of the magnitude of a complex-valued
* solution as demonstrated in step-29. Other uses are shown in step-32 and
// ---------------------------------------------------------------------
//
-// Copyright (C) 2010 - 2014 by the deal.II authors
+// Copyright (C) 2010 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
* Constructor. The <tt>filename</tt> is the common base name of
* all files and the argument <tt>digits</tt> should be the number
* of digits of the highest number in the sequence. File names by
- * default have the form "outputNN" with NNN the number set by the
+ * default have the form "outputNNN" with NNN the number set by the
* last step command. Numbers with less digits are filled with
* zeros from the left.
*/
// ---------------------------------------------------------------------
//
-// Copyright (C) 1999 - 2014 by the deal.II authors
+// Copyright (C) 1999 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
* <ul>
* <li> Linear spacing: The intervals are distributed in constant steps
* between the minimum and maximum values of the data.
- * <li> Logaritmic spacing: The intervals are distributed in constant steps
+ * <li> Logarithmic spacing: The intervals are distributed in constant steps
* between the minimum and maximum values of the logs of the values. This
* scheme is only useful if the data has only positive values. Negative and
* zero values are sorted into the leftmost interval.
* </ul>
*
- * To keep programs extendible, you can use the two functions @p
+ * To keep programs extensible, you can use the two functions @p
* get_interval_spacing_names and @p parse_interval_spacing, which always give
* you a complete list of spacing formats presently supported and are able to
* generate the respective value of the @p enum. If you use them, you can
*
* Return @p true, if (<tt>n1<n2</tt>, and (<tt>n1>0</tt> or
* <tt>n2<0</tt>)), or (n2<n1 and n1>0 and n2<=0). This in effect sorts all
- * negativ numbers to be larger than the largest positive number.
+ * negative numbers to be larger than the largest positive number.
*/
template <typename number>
static bool logarithmic_less (const number n1,
* structures of sparse matrices, it is relatively cheap. It may therefore
* be a win if you have many fixed degrees of freedom (e.g. boundary nodes),
* or if access to the sparse matrix is expensive (e.g. for block sparse
- * matrices, or for PETSc or trilinos matrices). However, it doesn't work as
+ * matrices, or for PETSc or Trilinos matrices). However, it doesn't work as
* expected if there are also hanging nodes to be considered. More caveats
* are listed in the general documentation of this class.
*
* This class provides an abstract interface to time dependent problems in
* that it addresses some of the most annoying aspects of this class of
* problems: data management. These problems frequently need large amounts of
- * computer ressources, most notably computing time, main memory and disk
+ * computer resources, most notably computing time, main memory and disk
* space. Main memory reduction is often the most pressing need, methods to
* implement it are almost always quite messy, though, quickly leading to code
* that stores and reloads data at places scattered all over the program, and
* step objects on which we solve our problem subsequently. In order to do so,
* we need knowledge of the data on zero or several previous timesteps (when
* using single or multiple step methods, that is) and maybe also some data of
- * time steps ahead (for example the computational grid on these). Dependening
+ * time steps ahead (for example the computational grid on these). Depending
* on the problem in question, a second loop over all timesteps may be done
* solving a dual problem, where the loop may run forward (one dual problem
* for each time step) or backward (using a global dual problem). Within one
* triangulation is deleted and the refinement history saved such that the
* respective @p wake_up function can rebuild it. You should therefore call
* this function from your overloaded version, preferably at the end so that
- * your function can use the triangulation as long as ou need it.
+ * your function can use the triangulation as long as you need it.
*/
virtual void sleep (const unsigned int);
* The resulting map is guaranteed to be interpolatory at the support points
* of a FE_Q() finite element of the same degree as dh->get_fe().degree.
* Notice that this may or may not be meaningful, depending on the
- * FiniteElement you have distribed in dh.
+ * FiniteElement you have distributed in dh.
*
* If the underlying finite element is an FE_Q(1)^spacedim, then the
* resulting VECTOR is a finite element field representation of the vertices
// ---------------------------------------------------------------------
//
-// Copyright (C) 2002 - 2014 by the deal.II authors
+// Copyright (C) 2002 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
{
// note that the FETools::get_fe_from_name function depends on the
// particular format of the string this function returns, so they have to be
- // kept in synch
+ // kept in sync
std::ostringstream namebuf;
namebuf << "FE_DGP<"
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2014 by the deal.II authors
+// Copyright (C) 2000 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
{
// note that the FETools::get_fe_from_name function depends on the
// particular format of the string this function returns, so they have to be
- // kept in synch
+ // kept in sync
std::ostringstream namebuf;
namebuf << "FE_Q_iso_Q1<"
rho_average += quad.weight(i)*(quad.point(i)-center).norm();
mid_point += quad.weight(i)*quad.point(i);
}
- // Project the mid_pont back to the right location
+ // Project the mid_point back to the right location
Tensor<1,spacedim> R = mid_point-center;
// Scale it to have radius rho_average
R *= rho_average/R.norm();
// ---------------------------------------------------------------------
//
-// Copyright (C) 2004 - 2014 by the deal.II authors
+// Copyright (C) 2004 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
MPI_Comm comm;
int ierr;
- // this ugly cast is necessay because the
+ // this ugly cast is necessary because the
// type Mat and PETScObject are
// unrelated.
ierr = PetscObjectGetComm(reinterpret_cast<PetscObject>(matrix), &comm);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2004 - 2014 by the deal.II authors
+// Copyright (C) 2004 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
int ierr;
/*
- TODO: PETSc dublicates communicators, so this does not work (you put MPI_COMM_SELF in, but get something other out when you ask PETSc for the communicator. This mainly fails due to the MatrixFree classes, that can not ask PETSc for a communicator. //Timo Heister
+ TODO: PETSc duplicates communicators, so this does not work (you put MPI_COMM_SELF in, but get something other out when you ask PETSc for the communicator. This mainly fails due to the MatrixFree classes, that can not ask PETSc for a communicator. //Timo Heister
Assert(A.get_mpi_communicator()==mpi_communicator, ExcMessage("PETSc Solver and Matrix need to use the same MPI_Comm."));
Assert(x.get_mpi_communicator()==mpi_communicator, ExcMessage("PETSc Solver and Vector need to use the same MPI_Comm."));
Assert(b.get_mpi_communicator()==mpi_communicator, ExcMessage("PETSc Solver and Vector need to use the same MPI_Comm."));
* The following class is used to describe the data needed to compute the
* finite difference approximation to the gradient on a cell. See the
* general documentation of this class for more information on
- * implementational details.
+ * implementation details.
*
* @author Wolfgang Bangerth, 2000
*/
* just like a
* <tt>std::pair<iterator,iterator></tt>
* but is templatized on the
- * dof handler that shouls be used.
+ * dof handler that should be used.
*/
template <typename DH>
struct IteratorRange
projects / dealii.git / commitdiff