Found via `codespell -q 3 -I ../dealii-word-whitelist.txt --skip="./bundled"` where whitelist consists of:
```
als
ans
buss
commend
ith
elemente
everytime
mapp
methode
nd
numer
perverse
pres
reenable
strat
substract
superceded
ue
uint
```
did not have the respective POSIX functions. This restriction is lifted
for the special case that you give one as the number of parties that
will be waiting for the barrier: in this case, a barrier is a
- no-operation, so we do not need assistence from the operating
+ no-operation, so we do not need assistance from the operating
system. This change makes it slightly simpler to write programs in a way
such that they run in both single- and multithreaded environments.
<br>
<li>
New: Add NURBSPatchManifold. This class is a child of ChartManifold and
- implements a manifold descriptor for the face of a CAD imported usign
+ implements a manifold descriptor for the face of a CAD imported using
OpenCASCADE.
<br>
(Mauro Bardelloni, 2016/03/09)
<li>
New: The tutorial step-59 shows a matrix-free solver for the Poisson
- equation discretized with the symmetric interior penalty discontinous
+ equation discretized with the symmetric interior penalty discontinuous
Galerkin method.
<br>
(Katharina Kormann, Martin Kronbichler, 2018/05/04)
<li>
New: Extend GridGenerator::extrude_triangulation to using exact slicing z-axis
- values and reimplement the exsiting GridGenerator::extrude_triangulation using
+ values and reimplement the existing GridGenerator::extrude_triangulation using
the newly developed overload.
<br>
(Weixiong Zheng, 2018/04/05)
<div class="twocolumn" style="width: 80%">
<div>
<img src="https://www.dealii.org/images/steps/developer/step_15_solution_1.png"
- alt="Solution after zero cycles with countour lines." width="230" height="273">
+ alt="Solution after zero cycles with contour lines." width="230" height="273">
</div>
<div>
<img src="https://www.dealii.org/images/steps/developer/step_15_solution_2.png"
- alt="Solution after one cycle with countour lines." width="230" height="273">
+ alt="Solution after one cycle with contour lines." width="230" height="273">
</div>
<div>
<img src="https://www.dealii.org/images/steps/developer/step_15_solution_3.png"
- alt="Solution after two cycles with countour lines." width="230" height="273">
+ alt="Solution after two cycles with contour lines." width="230" height="273">
</div>
<div>
<img src="https://www.dealii.org/images/steps/developer/step_15_solution_4.png"
- alt="Solution after three cycles with countour lines." width="230" height="273">
+ alt="Solution after three cycles with contour lines." width="230" height="273">
</div>
</div>
radius slightly greater than $d$; this shape should lead to a focusing of the sound
wave at the center of the circle. Varying $d$ changes the "focus" of the lens
and affects the spatial distribution of the intensity of $u$, where our main
-concern is how well $|u|=\sqrt{v^2+w^2}$ is focussed.
+concern is how well $|u|=\sqrt{v^2+w^2}$ is focused.
In the program below, we will implement the complex-valued Helmholtz equations
using the formulation with split real and imaginary parts. We will also
The first two pictures show the real and imaginary parts of
$u$, whereas the last shows the intensity $|u|$. One can clearly
-see that the intensity is focussed around the focal point of the
+see that the intensity is focused around the focal point of the
lens (0.5, 0.3), and that the focus
is rather sharp in $x$-direction but more blurred in $y$-direction, which is a
consequence of the geometry of the focusing lens, its finite aperture,
One solution is to use geometric multigrid methods as shown in step-16. They
are known to be very fast, and they are suitable for our purpose since all
ingredients, including the transfer between different grid levels, can be
-expressed in terms of matrix-vector products related to a colletion of
+expressed in terms of matrix-vector products related to a collection of
cells. All one needs to do is to find a smoother that is based on
matrix-vector products rather than all the matrix entries. One such candidate
would be a damped Jacobi iteration that requires access to the matrix
processors. A benefit of the design of this vector class is the way ghosted
entries are accessed. In the storage scheme of the vector, the data array
extends beyond the processor-local part of the solution with further vector
-entries available for the ghosted degrees of freedom. This gives a continguous
+entries available for the ghosted degrees of freedom. This gives a contiguous
index range for all locally active degrees of freedom. (Note that the index
range depends on the exact configuration of the mesh.) Since matrix-free
operations can be thought of doing linear algebra that is performance
set output "step-57.compare-Re400.svg"
-set xlabel "horizonal velocity"
+set xlabel "horizontal velocity"
set ylabel "y coordinate"
set xrange [-0.5: 1.0]
set title "horizontal velocity at x=0.5, Re=400"
set output "step-57.compare-Re7500.svg"
-set xlabel "horizonal velocity"
+set xlabel "horizontal velocity"
set ylabel "y coordinate"
set xrange [-0.5: 1.0]
set title "horizontal velocity at x=0.5, Re=7500"
set output "step-57.converge-Re7500.svg"
-set xlabel "horizonal velocity"
+set xlabel "horizontal velocity"
set ylabel "y coordinate"
set xrange [-0.5: 1.0]
set title "horizontal velocity at x=0.5, Re=7500"
* container type.
*
* Notice that the current content of variable @p t is ignored. Its type is
- * used to infer how to interpret the string. If the string is succesfully
+ * used to infer how to interpret the string. If the string is successfully
* parsed, then @p t will be set to the parsed content of @p s.
*
* @author Luca Heltai, 2018
auto p = dynamic_cast<const Patterns::Map *>(pattern.get());
AssertThrow(p,
ExcMessage("I need a Map pattern to convert a string to "
- "a Map compatbile type."));
+ "a Map compatible type."));
auto key_p = p->get_key_pattern().clone();
auto val_p = p->get_value_pattern().clone();
std::vector<std::string> vec(t.size());
auto p = dynamic_cast<const Patterns::List *>(pattern.get());
AssertThrow(p,
ExcMessage("I need a List pattern to convert a string "
- "to a List compatbile type."));
+ "to a List compatible type."));
auto base_p = p->get_base_pattern().clone();
std::vector<std::string> vec(dim);
auto p = dynamic_cast<const Patterns::List *>(pattern.get());
AssertThrow(p,
ExcMessage("I need a List pattern to convert a string "
- "to a List compatbile type."));
+ "to a List compatible type."));
auto base_p = p->get_base_pattern().clone();
T t;
auto p = dynamic_cast<const Patterns::List *>(pattern.get());
AssertThrow(p,
ExcMessage("I need a List pattern to convert a string "
- "to a List compatbile type."));
+ "to a List compatible type."));
const auto &expressions = t->get_expressions();
if (expressions.size() == 0)
auto p = dynamic_cast<const Patterns::List *>(pattern.get());
AssertThrow(p,
ExcMessage("I need a List pattern to convert a string "
- "to a List compatbile type."));
+ "to a List compatible type."));
const auto expressions =
Utilities::split_string_list(s, p->get_separator());
auto p = dynamic_cast<const Patterns::List *>(pattern.get());
AssertThrow(p,
ExcMessage("I need a List pattern to convert a string "
- "to a List compatbile type."));
+ "to a List compatible type."));
auto base_p = p->get_base_pattern().clone();
std::string s =
auto p = dynamic_cast<const Patterns::List *>(pattern.get());
AssertThrow(p,
ExcMessage("I need a List pattern to convert a string "
- "to a List compatbile type."));
+ "to a List compatible type."));
auto base_p = p->get_base_pattern().clone();
reord_2 = TensorAccessors::reordered_index_view<index_2, rank_2>(src2);
// Now, reorder index_3 to the end of src1. We have to make sure to
- // preserve the orginial ordering: index_1 has been removed. If
+ // preserve the original ordering: index_1 has been removed. If
// index_3 > index_1, we have to use (index_3 - 1) instead:
ReorderedIndexView<
(index_3 < index_1 ? index_3 : index_3 - 1),
rank_1 > (reord_1);
// Now, reorder index_4 to the end of src2. We have to make sure to
- // preserve the orginial ordering: index_2 has been removed. If
+ // preserve the original ordering: index_2 has been removed. If
// index_4 > index_2, we have to use (index_4 - 1) instead:
ReorderedIndexView<
(index_4 < index_2 ? index_4 : index_4 - 1),
/**
* Computes the Jacobian of the vector field.
*
- * The Jacobian of a vector field is in essense the gradient of each
+ * The Jacobian of a vector field is in essence the gradient of each
* dependent variable with respect to all independent variables.
* This operation is therefore analogous to the gradient() operation
* performed on a collection of scalar valued fields.
/**
* Computes the Jacobian of the vector field.
*
- * The Jacobian of a vector field is in essense the gradient of each
+ * The Jacobian of a vector field is in essence the gradient of each
* dependent variable with respect to all independent variables.
* This operation is therefore analogous to the gradient() operation
* performed on a collection of scalar valued fields.
<< counts[15] << "\n"
<< "Number of 'abs' calls that can switch branch: " << counts[16]
<< "\n"
- << "Number of parameters (doubles) interchangable without retaping: "
+ << "Number of parameters (doubles) interchangeable without retaping: "
<< counts[17] << "\n"
<< std::flush;
}
}
# else
// If ADOL-C is not configured with tapeless number reference counting
- // then there is no way that we can guarentee that the following call
+ // then there is no way that we can guarantee that the following call
// is safe. No comment... :-/
adtl::setNumDir(n_directional_derivatives);
# endif
n_dependent_variables() const;
/**
- * Prints the status of all queriable data. Exactly what is printed and
+ * Prints the status of all queryable data. Exactly what is printed and
* its format depends on the @p ad_type, as is determined by the
* @p ADNumberTypeCode template parameter.
*
* class, the following requirements have to be met:
* <ul>
* <li>
- * The hp::DoFHandler needs to be explicitely mentioned
+ * The hp::DoFHandler needs to be explicitly mentioned
* in the parallel::distributed::SolutionTransfer type, i.e.:
* @code
* parallel::distributed::SolutionsTransfer<dim, VectorType,
* first child is marked with `CELL_REFINE`, whereas the others will be
* marked with `CELL_INVALID`, which indicates that these cells will be
* ignored by default during the packing or unpacking process. This
- * ensures that data is only transfered once onto or from the parent
+ * ensures that data is only transferred once onto or from the parent
* cell. If the callback is called with `CELL_REFINE`, the callback
* will want to pack up the data on this cell into an array and store
* it at the provided address for later unpacking in a way so that
* This is because these member variables may be initialized only
* on demand by derived classes, rather than being available immediately.
* Consequently, comparing these members would not only be costly because
- * these are generall big arrays, but also because their computation may
+ * these are generally big arrays, but also because their computation may
* be expensive. On the other hand, derived classes for which these
* arrays may differ for two objects even though the above list compares
* as equal, will probably want to implement their own operator==()
* img[src="3source_fe_indices.png"]{width:25%;}</style> \endhtmlonly
* @image html 3source_fe_indices.png "Active FE indices"
*
- * As discussed before, the colors of predicates are alloted using
+ * As discussed before, the colors of predicates are allotted using
* the graph coloring algorithm. Each predicate is a node in the graph and if
* two sub-domains share an interface, the corresponding predicates
* should be given different colors.
* Quadrature points computed using this mapping lie on the exact
* geometrical objects, and tangent and normal vectors computed using
* this class are tangent and normal to the underlying geometry. This
- * is in constrast with the MappingQ class, which approximates the
+ * is in contrast with the MappingQ class, which approximates the
* geometry using a polynomial of some order, and then computes the
* normals and tangents using the approximated surface.
*
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
- * <tt>end(r)</tt>. Note also that the iterator may not be dereferencable in
+ * <tt>end(r)</tt>. Note also that the iterator may not be dereferenceable in
* that case.
*
* Note that due to the layout in ChunkSparseMatrix, iterating over matrix
* end of line @p r, or past the end of the entire sparsity pattern. This is
* the version for constant matrices.
*
- * Note that the end iterator is not necessarily dereferencable. This is in
+ * Note that the end iterator is not necessarily dereferenceable. This is in
* particular the case if it is the end iterator for the last row of a
* matrix.
*
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
- * <tt>end(r)</tt>. Note also that the iterator may not be dereferencable in
+ * <tt>end(r)</tt>. Note also that the iterator may not be dereferenceable in
* that case.
*
* Note that due to the layout in ChunkSparseMatrix, iterating over matrix
* end of line @p r, or past the end of the entire sparsity pattern. This is
* the version for non-constant matrices.
*
- * Note that the end iterator is not necessarily dereferencable. This is in
+ * Note that the end iterator is not necessarily dereferenceable. This is in
* particular the case if it is the end iterator for the last row of a
* matrix.
*
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
- * <tt>end(r)</tt>. Note also that the iterator may not be dereferencable in
+ * <tt>end(r)</tt>. Note also that the iterator may not be dereferenceable in
* that case.
*/
iterator
* Final iterator of row <tt>r</tt>. It points to the first element past the
* end of line @p r, or past the end of the entire sparsity pattern.
*
- * Note that the end iterator is not necessarily dereferencable. This is in
+ * Note that the end iterator is not necessarily dereferenceable. This is in
* particular the case if it is the end iterator for the last row of a
* matrix.
*/
AdditionalData(bool use_level_analysis = true);
/**
- * Flag that determines if level informations are used when creating and
+ * Flag that determines if level information is used when creating and
* applying the preconditioner. See the documentation for
* cusparseSolvePolicy_t at
* https://docs.nvidia.com/cuda/cusparse/index.html#cusparsesolvepolicy_t
AdditionalData(bool use_level_analysis = true);
/**
- * Flag that determines if level informations are used when creating and
+ * Flag that determines if level information is used when creating and
* applying the preconditioner. See the documentation for
* cusparseSolvePolicy_t at
* https://docs.nvidia.com/cuda/cusparse/index.html#cusparsesolvepolicy_t
operator*=(const Number factor);
/**
- * Divide the entrie matrix by a fixed factor.
+ * Divide the entire matrix by a fixed factor.
*/
SparseMatrix &
operator/=(const Number factor);
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
- * <tt>end(r)</tt>. Note also that the iterator may not be dereferencable in
+ * <tt>end(r)</tt>. Note also that the iterator may not be dereferenceable in
* that case.
*
* Note also the discussion in the general documentation of this class about
* Final iterator of row <tt>r</tt>. It points to the first element past the
* end of line @p r, or past the end of the entire sparsity pattern.
*
- * Note that the end iterator is not necessarily dereferencable. This is in
+ * Note that the end iterator is not necessarily dereferenceable. This is in
* particular the case if it is the end iterator for the last row of a
* matrix.
*/
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
- * <tt>end(r)</tt>. Note also that the iterator may not be dereferencable
+ * <tt>end(r)</tt>. Note also that the iterator may not be dereferenceable
* in that case.
*/
const_iterator
* Final iterator of row <tt>r</tt>. It points to the first element past
* the end of line @p r, or past the end of the entire sparsity pattern.
*
- * Note that the end iterator is not necessarily dereferencable. This is
+ * Note that the end iterator is not necessarily dereferenceable. This is
* in particular the case if it is the end iterator for the last row of a
* matrix.
*/
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
- * <tt>end(r)</tt>. The returned iterator may not be dereferencable in that
+ * <tt>end(r)</tt>. The returned iterator may not be dereferenceable in that
* case if neither row @p r nor any of the following rows contain any
* nonzero entries.
*/
* or past the end of the entire sparsity pattern if none of the rows after
* @p r contain any entries at all.
*
- * Note that the end iterator is not necessarily dereferencable. This is in
+ * Note that the end iterator is not necessarily dereferenceable. This is in
* particular the case if it is the end iterator for the last row of a
* matrix.
*/
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
- * <tt>end(r)</tt>. Note also that the iterator may not be dereferencable in
+ * <tt>end(r)</tt>. Note also that the iterator may not be dereferenceable in
* that case.
*
* Note also the discussion in the general documentation of this class about
* Final iterator of row <tt>r</tt>. It points to the first element past the
* end of line @p r, or past the end of the entire sparsity pattern.
*
- * Note that the end iterator is not necessarily dereferencable. This is in
+ * Note that the end iterator is not necessarily dereferenceable. This is in
* particular the case if it is the end iterator for the last row of a
* matrix.
*/
trilinos_vector() const;
/**
- * Return a (modifyable) reference to the underlying Trilinos
+ * Return a (modifiable) reference to the underlying Trilinos
* Epetra_FEVector class.
*/
Epetra_FEVector &
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
- * <tt>end(r)</tt>. The returned iterator may not be dereferencable in
+ * <tt>end(r)</tt>. The returned iterator may not be dereferenceable in
* that case if neither row @p r nor any of the following rows contain any
* nonzero entries.
*
* or past the end of the entire sparsity pattern if none of the rows
* after @p r contain any entries at all.
*
- * Note that the end iterator is not necessarily dereferencable. This is
+ * Note that the end iterator is not necessarily dereferenceable. This is
* in particular the case if it is the end iterator for the last row of a
* matrix.
*/
* 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 way that
+ * 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).
*/
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
- * <tt>end(r)</tt>. Note also that the iterator may not be dereferencable
+ * <tt>end(r)</tt>. Note also that the iterator may not be dereferenceable
* in that case.
*/
const_iterator
* Final iterator of row <tt>r</tt>. It points to the first element past
* the end of line @p r, or past the end of the entire sparsity pattern.
*
- * Note that the end iterator is not necessarily dereferencable. This is
+ * Note that the end iterator is not necessarily dereferenceable. This is
* in particular the case if it is the end iterator for the last row of a
* matrix.
*/
trilinos_vector() const;
/**
- * Return a (modifyable) reference to the underlying Trilinos
+ * Return a (modifiable) reference to the underlying Trilinos
* Epetra_FEVector class.
*/
Epetra_FEVector &
* Stores the index offset into the arrays @p jxw_values, @p jacobians,
* @p normal_vectors and the second derivatives. Note that affine cells
* have shorter fields of length 1, where the others have lengths equal
- * to the numer of quadrature points of the given cell.
+ * to the number of quadrature points of the given cell.
*/
AlignedVector<unsigned int> data_index_offsets;
// A helper function to identify block vectors with many components where we
- // should not try to overlap computations and communcation because there
- // would be too many outstanding communcation requests. This is the base case
+ // should not try to overlap computations and communication because there
+ // would be too many outstanding communication requests. This is the base case
// for generic vectors
template <typename VectorStruct>
constexpr unsigned int
* integration. Depending on the task the mesh worker loop is performing,
* local results can be of different types. They have in common that they
* are the result of local integration over a cell or face. Their actual
- * type is determined by the Assember using them. It is also the assembler
+ * type is determined by the Assembler using them. It is also the assembler
* setting the arrays of local results to the sizes needed. Here is a list
- * of the provided data types and the assembers using them:
+ * of the provided data types and the assemblers using them:
*
* <ol>
* <li> n_values() numbers accessed with value(), and stored in the data
/**
* The number of scalar values.
*
- * This number is set to a nonzero value by Assember::CellsAndFaces
+ * This number is set to a nonzero value by Assembler::CellsAndFaces
*
*/
unsigned int
/**
* The number of vectors.
*
- * This number is set to a nonzero value by Assember::ResidualSimple and
- * Assember::ResidualLocalBlocksToGlobalBlocks.
+ * This number is set to a nonzero value by Assembler::ResidualSimple and
+ * Assembler::ResidualLocalBlocksToGlobalBlocks.
*/
unsigned int
n_vectors() const;
#include <deal.II/multigrid/mg_constrained_dofs.h>
/*
- * The header containing the classes MeshWorker::Assember::MatrixSimple,
- * MeshWorker::Assember::MGMatrixSimple, MeshWorker::Assember::ResidualSimple,
- * and MeshWorker::Assember::SystemSimple.
+ * The header containing the classes MeshWorker::Assembler::MatrixSimple,
+ * MeshWorker::Assembler::MGMatrixSimple, MeshWorker::Assembler::ResidualSimple,
+ * and MeshWorker::Assembler::SystemSimple.
*/
DEAL_II_NAMESPACE_OPEN
tol);
tangential /= tangential.norm();
- // Compute the entires of the linear system
+ // Compute the entries of the linear system
// Note the system is symmetric so we could only compute the
// lower/upper triangle.
//
q_point < fe_face_values.n_quadrature_points;
++q_point)
{
- // Compute the entires of the linear system
+ // Compute the entries of the linear system
// Note the system is symmetric so we could only compute the
// lower/upper triangle.
//
};
/**
- * Manifold description for the face of a CAD imported usign OpenCASCADE.
+ * Manifold description for the face of a CAD imported using OpenCASCADE.
*
* @ingroup manifold
*
import_targets_data = import_targets_temp;
}
- // now that we know how many indices each process will recieve from
+ // now that we know how many indices each process will receive from
// ghosts, send and receive indices for import data. non-blocking receives
// and blocking sends
std::vector<types::global_dof_index> expanded_import_indices(
std::vector<std::string> pair =
Utilities::split_string_list(key_value_pair, key_value_separator);
- // Check that we have in fact two mathces
+ // Check that we have in fact two matches
if (pair.size() != 2)
return false;
void
TableHandler::clear_current_row()
{
- // Figure out what is the currect (max) length of the columns
+ // Figure out what is the correct (max) length of the columns
// so that we "shave" one off.
std::vector<internal::TableEntry>::size_type n = 0;
for (std::map<std::string, Column>::iterator p = columns.begin();
// finally, after syncing the parallel_forest with the triangulation,
// also update the quadrant_cell_relations, which will be used for
// repartitioning, further refinement/coarsening, and unpacking
- // of stored or transfered data.
+ // of stored or transferred data.
update_quadrant_cell_relations();
}
{
// This function sets up the values of the polynomials we want to
// take moments with in the quadrature points. In fact, we multiply
- // thos by the weights, such that the sum of function values and
+ // those by the weights, such that the sum of function values and
// test_values over quadrature points yields the interpolated degree
// of freedom.
template <int dim>
}
}
- // Calulate the gradient of sigma_imj_values[q][i][j] =
+ // Calculate the gradient of sigma_imj_values[q][i][j] =
// sigma[q][i]-sigma[q][j]
// - this depends on the component and the direction of the
// corresponding edge.
// lines and vertices. Now we have to
// consider outer ones as well. here, we have
// to check, whether there are other cells
- // still needing these objects. oherwise we
+ // still needing these objects. otherwise we
// can delete them. first for quads (and
// their inner lines).
* in two iteration cycles through the map. First, existence check, then
* returning the value.
*
- * 2- Using std::map::find(): This option is less readble, but theoretically
+ * 2- Using std::map::find(): This option is less readable, but theoretically
* faster, because it results in one iteration through std::map object.
*
* We decided to use the 2nd option.
const types::blas_int nn = B.n();
const types::blas_int kk = B.m();
- // lapack does not have any tripple product routines, including the case of
+ // lapack does not have any triple product routines, including the case of
// diagonal matrix in the middle, see
// https://stackoverflow.com/questions/3548069/multiplying-three-matrices-in-blas-with-the-middle-one-being-diagonal
// http://mathforum.org/kb/message.jspa?messageID=3546564
VectorOperation::values operation,
std::shared_ptr<const CommunicationPatternBase> communication_pattern)
{
- // If no communication pattern is given, create one. Otherwsie, use the
+ // If no communication pattern is given, create one. Otherwise, use the
// one given.
if (communication_pattern == nullptr)
{
data_out.clear_data_vectors();
data_out.add_data_vector(solution, "solution");
data_out.build_patches();
- deallog << "Interpolated/tranferred solution after pure refinement"
+ deallog << "Interpolated/transferred solution after pure refinement"
<< std::endl
<< std::endl;
data_out.write_gnuplot(out);
data_out.clear_data_vectors();
data_out.add_data_vector(solution, "solution");
data_out.build_patches();
- deallog << "Interpolated/tranferred solution after coarsening" << std::endl
+ deallog << "Interpolated/transferred solution after coarsening" << std::endl
<< std::endl;
data_out.write_gnuplot(out);
}
1.000 1.000 0.4947
-DEAL::Interpolated/tranferred solution after pure refinement
+DEAL::Interpolated/transferred solution after pure refinement
DEAL::
# This file was generated by the deal.II library.
1.000 1.000 0.4947
-DEAL::Interpolated/tranferred solution after coarsening
+DEAL::Interpolated/transferred solution after coarsening
DEAL::
# This file was generated by the deal.II library.
1.000 1.000 1.000 -0.1382
-DEAL::Interpolated/tranferred solution after pure refinement
+DEAL::Interpolated/transferred solution after pure refinement
DEAL::
# This file was generated by the deal.II library.
1.000 1.000 1.000 -0.1382
-DEAL::Interpolated/tranferred solution after coarsening
+DEAL::Interpolated/transferred solution after coarsening
DEAL::
# This file was generated by the deal.II library.
-// Same as quadrature_point_data_2.cc, but for different base and actuall data
+// Same as quadrature_point_data_2.cc, but for different base and actual data
// classes.
q_data_out.clear_data_vectors();
q_data_out.add_data_vector(q_solution, "solution");
q_data_out.build_patches();
- deallog << "Interpolated/tranferred solution after pure refinement, FE_Q"
+ deallog << "Interpolated/transferred solution after pure refinement, FE_Q"
<< std::endl
<< std::endl;
q_data_out.write_gnuplot(out);
dgq_data_out.clear_data_vectors();
dgq_data_out.add_data_vector(dgq_solution, "solution");
dgq_data_out.build_patches();
- deallog << "Interpolated/tranferred solution after pure refinement, FE_DGQ"
+ deallog << "Interpolated/transferred solution after pure refinement, FE_DGQ"
<< std::endl
<< std::endl;
dgq_data_out.write_gnuplot(out);
q_data_out.add_data_vector(q_solution, "solution");
q_data_out.build_patches();
deallog
- << "Interpolated/tranferred solution after coarsening and refinement, FE_Q"
+ << "Interpolated/transferred solution after coarsening and refinement, FE_Q"
<< std::endl
<< std::endl;
q_data_out.write_gnuplot(out);
dgq_data_out.add_data_vector(dgq_solution, "solution");
dgq_data_out.build_patches();
deallog
- << "Interpolated/tranferred solution after coarsening and refinement, FE_DGQ"
+ << "Interpolated/transferred solution after coarsening and refinement, FE_DGQ"
<< std::endl
<< std::endl;
dgq_data_out.write_gnuplot(out);
1.00000 -0.760380
-DEAL::Interpolated/tranferred solution after pure refinement, FE_Q
+DEAL::Interpolated/transferred solution after pure refinement, FE_Q
DEAL::
# This file was generated by the deal.II library.
1.00000 -0.756802
-DEAL::Interpolated/tranferred solution after pure refinement, FE_DGQ
+DEAL::Interpolated/transferred solution after pure refinement, FE_DGQ
DEAL::
# This file was generated by the deal.II library.
1.00000 -0.760380
-DEAL::Interpolated/tranferred solution after coarsening and refinement, FE_Q
+DEAL::Interpolated/transferred solution after coarsening and refinement, FE_Q
DEAL::
# This file was generated by the deal.II library.
0.156250 0.580532
-DEAL::Interpolated/tranferred solution after coarsening and refinement, FE_DGQ
+DEAL::Interpolated/transferred solution after coarsening and refinement, FE_DGQ
DEAL::
# This file was generated by the deal.II library.
1.00000 1.00000 0.515586
-DEAL::Interpolated/tranferred solution after pure refinement, FE_Q
+DEAL::Interpolated/transferred solution after pure refinement, FE_Q
DEAL::
# This file was generated by the deal.II library.
1.00000 1.00000 0.494679
-DEAL::Interpolated/tranferred solution after pure refinement, FE_DGQ
+DEAL::Interpolated/transferred solution after pure refinement, FE_DGQ
DEAL::
# This file was generated by the deal.II library.
1.00000 1.00000 0.515586
-DEAL::Interpolated/tranferred solution after coarsening and refinement, FE_Q
+DEAL::Interpolated/transferred solution after coarsening and refinement, FE_Q
DEAL::
# This file was generated by the deal.II library.
0.0625000 0.187500 0.169943
-DEAL::Interpolated/tranferred solution after coarsening and refinement, FE_DGQ
+DEAL::Interpolated/transferred solution after coarsening and refinement, FE_DGQ
DEAL::
# This file was generated by the deal.II library.
1.00000 1.00000 1.00000 29.6768
-DEAL::Interpolated/tranferred solution after pure refinement, FE_Q
+DEAL::Interpolated/transferred solution after pure refinement, FE_Q
DEAL::
# This file was generated by the deal.II library.
1.00000 1.00000 1.00000 27.0086
-DEAL::Interpolated/tranferred solution after pure refinement, FE_DGQ
+DEAL::Interpolated/transferred solution after pure refinement, FE_DGQ
DEAL::
# This file was generated by the deal.II library.
1.00000 1.00000 1.00000 29.6768
-DEAL::Interpolated/tranferred solution after coarsening and refinement, FE_Q
+DEAL::Interpolated/transferred solution after coarsening and refinement, FE_Q
DEAL::
# This file was generated by the deal.II library.
0.125000 0.375000 0.125000 0.0485576
-DEAL::Interpolated/tranferred solution after coarsening and refinement, FE_DGQ
+DEAL::Interpolated/transferred solution after coarsening and refinement, FE_DGQ
DEAL::
# This file was generated by the deal.II library.
int
main(int argc, char **argv)
{
- // Intialize MPI as required by Zoltan library used for graph coloring by this
- // test.
+ // Initialize MPI as required by Zoltan library used for graph coloring by
+ // this test.
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv);
MPILogInitAll all;
int
main(int argc, char **argv)
{
- // Intialize MPI as required by Zoltan library used for graph coloring by this
- // test.
+ // Initialize MPI as required by Zoltan library used for graph coloring by
+ // this test.
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv);
MPILogInitAll all;
// print color predicate pairs for a cell
// Note that here material id is used to identify cells
- // Here (1,2) indicates predicate 2 of color 1 is relavant for cell.
+ // Here (1,2) indicates predicate 2 of color 1 is relevant for cell.
deallog << "(color, enrichment_func_id):";
for (auto color_predicate_pair :
cellwise_color_predicate_map[cell->material_id()])
int
main(int argc, char **argv)
{
- // Intialize MPI as required by Zoltan library used for graph coloring by this
- // test.
+ // Initialize MPI as required by Zoltan library used for graph coloring by
+ // this test.
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv);
MPILogInitAll all;
int
main(int argc, char **argv)
{
- // Intialize MPI as required by Zoltan library used for graph coloring by this
- // test.
+ // Initialize MPI as required by Zoltan library used for graph coloring by
+ // this test.
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv);
MPILogInitAll all;
int
main(int argc, char **argv)
{
- // Intialize MPI as required by Zoltan library used for graph coloring by this
- // test.
+ // Initialize MPI as required by Zoltan library used for graph coloring by
+ // this test.
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv);
MPILogInitAll all;
<< norm_rel_change_new << std::endl;
}
- // moniter relative change of norm in later stages
+ // monitor relative change of norm in later stages
if (cycle > 1)
{
deallog << (norm_rel_change_new < norm_rel_change_old)
problem.run();
}
else
- AssertThrow(false, ExcMessage("Dimension incorect. dim can be 2 or 3"));
+ AssertThrow(false,
+ ExcMessage("Dimension incorrect. dim can be 2 or 3"));
}
problem.run();
}
else
- AssertThrow(false, ExcMessage("Dimension incorect. dim can be 2 or 3"));
+ AssertThrow(false,
+ ExcMessage("Dimension incorrect. dim can be 2 or 3"));
}
problem.run();
}
else
- AssertThrow(false, ExcMessage("Dimension incorect. dim can be 2 or 3"));
+ AssertThrow(false,
+ ExcMessage("Dimension incorrect. dim can be 2 or 3"));
}
}
}
int
main(int argc, char **argv)
{
- // Intialize MPI as required by Zoltan library used for graph coloring by this
- // test.
+ // Initialize MPI as required by Zoltan library used for graph coloring by
+ // this test.
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv);
MPILogInitAll all;
// d/dx1 N0 = -(1-x2)
// d/dx2 N0 = -(1-x1)
// and same for other support points
-// To facilitate comparision, we use auxiliary scalar-valued FE
+// To facilitate comparison, we use auxiliary scalar-valued FE
// and take its values and gradients. For primitive FEs we can
// deduce which coefficient of tensor-valued shape function is
// nonzero and compare values/gradient to the scalar-valued counterpart.
// ---------------------------------------------------------------------
-// Test whether Assember::CellsAndFaces adds up correctly.
+// Test whether Assembler::CellsAndFaces adds up correctly.
#include <deal.II/dofs/dof_tools.h>
// ---------------------------------------------------------------------
-// Test whether Assember::Functional adds up correctly.
+// Test whether Assembler::Functional adds up correctly.
#include <deal.II/dofs/dof_tools.h>
// ---------------------------------------------------------------------
-// Test whether the various assember classes put the right data in the
+// Test whether the various assembler classes put the right data in the
// right place.
#include <deal.II/dofs/dof_tools.h>
// ---------------------------------------------------------------------
-// Test whether the various assember classes put the right data in the
+// Test whether the various assembler classes put the right data in the
// right place.
#include <deal.II/dofs/dof_tools.h>
//
// ---------------------------------------------------------------------
-// Tests for block_operator for opertaions with identical source destinations
+// Tests for block_operator for operations with identical source destinations
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_tools.h>
invM *
linear_operator<LinearAlgebra::distributed::Vector<double>>(laplace) * invM;
- // Do actuall work:
+ // Do actual work:
LinearAlgebra::distributed::Vector<double> init_vector;
mf_data->initialize_dof_vector(init_vector);
for (auto it = init_vector.begin(); it != init_vector.end(); ++it)
// ---------------------------------------------------------------------
-// Test whether the various assember classes put the right data in the
+// Test whether the various assembler classes put the right data in the
// right place.
// This test is a modification of the test with the same name in ../integrators
// ghost: 0 1 2 3 is3
// subset: 1 2 is2
//
- // expected result udpate ghosts()
+ // expected result update ghosts()
//
// rank 0 : 00 01 02 03 04 05 06 07 00 00 00 00
// rank 1 : 00 00 00 00 00 00 00 00 00 01 02 00
deallog << "#cells = " << tr.n_global_active_cells() << std::endl;
deallog << "proc " << myid << ", n levels " << tr.n_levels() << std::endl;
- deallog << "proc " << myid << ", n gobal levels " << tr.n_global_levels()
+ deallog << "proc " << myid << ", n global levels " << tr.n_global_levels()
<< std::endl;
deallog << "begin().cell_index " << tr.begin()->index() << std::endl;
DEAL:0:2d::#cells = 4
DEAL:0:2d::proc 0, n levels 1
-DEAL:0:2d::proc 0, n gobal levels 2
+DEAL:0:2d::proc 0, n global levels 2
DEAL:0:2d::begin().cell_index 0
DEAL:0:2d::begin(0).cell_index 0
DEAL:0:2d::begin(1)==end(1)? 1
DEAL:0:2d::OK
DEAL:1:2d::proc 1, n levels 1
-DEAL:1:2d::proc 1, n gobal levels 2
+DEAL:1:2d::proc 1, n global levels 2
DEAL:1:2d::begin().cell_index 0
DEAL:1:2d::begin(0).cell_index 0
DEAL:1:2d::begin(1)==end(1)? 1
DEAL:2:2d::proc 2, n levels 2
-DEAL:2:2d::proc 2, n gobal levels 2
+DEAL:2:2d::proc 2, n global levels 2
DEAL:2:2d::begin().cell_index 0
DEAL:2:2d::begin(0).cell_index 0
DEAL:2:2d::begin(1)==end(1)? 0
DEAL:3:2d::proc 3, n levels 1
-DEAL:3:2d::proc 3, n gobal levels 2
+DEAL:3:2d::proc 3, n global levels 2
DEAL:3:2d::begin().cell_index 0
DEAL:3:2d::begin(0).cell_index 0
DEAL:3:2d::begin(1)==end(1)? 1
DEAL:4:2d::proc 4, n levels 1
-DEAL:4:2d::proc 4, n gobal levels 2
+DEAL:4:2d::proc 4, n global levels 2
DEAL:4:2d::begin().cell_index 0
DEAL:4:2d::begin(0).cell_index 0
DEAL:4:2d::begin(1)==end(1)? 1
DEAL:5:2d::proc 5, n levels 1
-DEAL:5:2d::proc 5, n gobal levels 2
+DEAL:5:2d::proc 5, n global levels 2
DEAL:5:2d::begin().cell_index 0
DEAL:5:2d::begin(0).cell_index 0
DEAL:5:2d::begin(1)==end(1)? 1
DEAL:6:2d::proc 6, n levels 1
-DEAL:6:2d::proc 6, n gobal levels 2
+DEAL:6:2d::proc 6, n global levels 2
DEAL:6:2d::begin().cell_index 0
DEAL:6:2d::begin(0).cell_index 0
DEAL:6:2d::begin(1)==end(1)? 1
DEAL:7:2d::proc 7, n levels 1
-DEAL:7:2d::proc 7, n gobal levels 2
+DEAL:7:2d::proc 7, n global levels 2
DEAL:7:2d::begin().cell_index 0
DEAL:7:2d::begin(0).cell_index 0
DEAL:7:2d::begin(1)==end(1)? 1
DEAL:8:2d::proc 8, n levels 1
-DEAL:8:2d::proc 8, n gobal levels 2
+DEAL:8:2d::proc 8, n global levels 2
DEAL:8:2d::begin().cell_index 0
DEAL:8:2d::begin(0).cell_index 0
DEAL:8:2d::begin(1)==end(1)? 1
DEAL:9:2d::proc 9, n levels 1
-DEAL:9:2d::proc 9, n gobal levels 2
+DEAL:9:2d::proc 9, n global levels 2
DEAL:9:2d::begin().cell_index 0
DEAL:9:2d::begin(0).cell_index 0
DEAL:9:2d::begin(1)==end(1)? 1
DEAL:0:2d::#cells = 4
DEAL:0:2d::proc 0, n levels 2
-DEAL:0:2d::proc 0, n gobal levels 2
+DEAL:0:2d::proc 0, n global levels 2
DEAL:0:2d::begin().cell_index 0
DEAL:0:2d::begin(0).cell_index 0
DEAL:0:2d::begin(1)==end(1)? 0
DEAL:0:2d::OK
DEAL:1:2d::proc 1, n levels 1
-DEAL:1:2d::proc 1, n gobal levels 2
+DEAL:1:2d::proc 1, n global levels 2
DEAL:1:2d::begin().cell_index 0
DEAL:1:2d::begin(0).cell_index 0
DEAL:1:2d::begin(1)==end(1)? 1
DEAL:0:2d::#cells = 4
DEAL:0:2d::proc 0, n levels 2
-DEAL:0:2d::proc 0, n gobal levels 2
+DEAL:0:2d::proc 0, n global levels 2
DEAL:0:2d::begin().cell_index 0
DEAL:0:2d::begin(0).cell_index 0
DEAL:0:2d::begin(1)==end(1)? 0
DEAL:0:2d::OK
DEAL:1:2d::proc 1, n levels 1
-DEAL:1:2d::proc 1, n gobal levels 2
+DEAL:1:2d::proc 1, n global levels 2
DEAL:1:2d::begin().cell_index 0
DEAL:1:2d::begin(0).cell_index 0
DEAL:1:2d::begin(1)==end(1)? 1
DEAL:2:2d::proc 2, n levels 1
-DEAL:2:2d::proc 2, n gobal levels 2
+DEAL:2:2d::proc 2, n global levels 2
DEAL:2:2d::begin().cell_index 0
DEAL:2:2d::begin(0).cell_index 0
DEAL:2:2d::begin(1)==end(1)? 1
DEAL:3:2d::proc 3, n levels 1
-DEAL:3:2d::proc 3, n gobal levels 2
+DEAL:3:2d::proc 3, n global levels 2
DEAL:3:2d::begin().cell_index 0
DEAL:3:2d::begin(0).cell_index 0
DEAL:3:2d::begin(1)==end(1)? 1
for (unsigned int i = 0; i < 2; i++)
storage.add(0.1 * (i + 1));
- // 2 elemens
+ // 2 elements
deallog << "initial:" << std::endl;
for (unsigned int i = 0; i < storage.size(); i++)
deallog << storage[i] << std::endl;
// Check that all the functionality needed for calling
-// AffineConstraints<double>::distribute_local_to_global on mutiple combinations
-// of PETScWrappers objects is correctly instantiated and works.
+// AffineConstraints<double>::distribute_local_to_global on multiple
+// combinations of PETScWrappers objects is correctly instantiated and works.
#include <deal.II/lac/affine_constraints.h>
#include <deal.II/lac/full_matrix.h>
// ---------------------------------------------------------------------
-// check generic contract variants tha allow to specify the indices which
+// check generic contract variants that allow to specify the indices which
// will be contracted.
#include <deal.II/base/tensor.h>
projects / dealii.git / commitdiff