routines.append(FortranRoutine(file_name, guard_fp))
except NotImplementedError:
# not a lot we can do. If its in the whitelist we will fail
- # again later anway
+ # again later anyway
continue
routines.sort(key=lambda u: u.general_name)
#
# This script does the same thing as contrib/utilities/indent-all but only
# reformats files which have changed (or have been added but neither
-# staged/commited) since the last merge commit to the master branch.
+# staged/committed) since the last merge commit to the master branch.
#
# The script needs to be executed as
# ./contrib/utilities/indent
"By default only \"examples\", \"include\", "
"\"source\" and \"tests\" "
"directories are chosen to work on."
- "Path to directories can be both abosulte or relative.")
+ "Path to directories can be both absolute or relative.")
parser.add_argument("-j", metavar="THREAD_COUNT", type=int, default=0,
help="Number of clang-format instances to be run "
* that, with the appropriate implementation, both first and second derivatives can be computed exactly.
* -# With <em>taped</em> approaches, a specified subregion of code is selected as one for which all
* operations executed with active (marked) input variables are tracked and recorded in a data structure
- * referred to as a tape. At the end of the taped region, the recorded function(s) may be revaluated
+ * referred to as a tape. At the end of the taped region, the recorded function(s) may be reevaluated
* by "replaying" the tape with a different set of input variables instead of recomputing the function
* directly. Assuming that the taped region represents a smooth function, arbitrarily high-order
* derivatives of the function then can be computed by referring to the code path tracked and stored on
* graph is required.
*
* In reverse-mode, the chain-rule is computed somewhat unnaturally from the "outside in". The
- * values of the dependent variables first get computed and fixed, and then the preceeding
+ * values of the dependent variables first get computed and fixed, and then the preceding
* differential operations are evaluated and multiplied in succession with the previous results
* from left to right. Again, if we encapsulate and fix the order of operations using parentheses,
* this implies that the reverse calculation is performed by
* in the Mapping class (see the @ref mapping module), which however obtains
* its information about the boundary of the domain from the classes
* described here. The same is, of course, true when integrating boundary
- * terms (e.g., inhomogenous Neumann boundary conditions).
+ * terms (e.g., inhomogeneous Neumann boundary conditions).
*
* <li> Domains with nonzero codimension: In cases where a Triangulation is
* embedded into a higher dimensional space, i.e., whenever the second
-New: Added RTree class and pack_rtree() function to create a boost::gemoetry::index::rtree from
+New: Added RTree class and pack_rtree() function to create a boost::geometry::index::rtree from
containers and/or iterators of BoundingBox, Point, or Segment objects.
<br>
(Luca Heltai, 2018/10/06)
// build non-homogeneous constraints in the zeroth iteration (that is, when
// `apply_dirichlet_bc == true`) and build only the corresponding
// homogeneous constraints in the following step. While the current
- // example has only homogenous constraints, previous experiences have
+ // example has only homogeneous constraints, previous experiences have
// shown that a common error is forgetting to add the extra condition when
// refactoring the code to specific uses. This could lead errors that are
// hard to debug. In this spirit, we choose to make the code more verbose
necessary to compute integrals using curved approximations of the boundary,
i.e., describe each edge or face of cells as curves, instead of straight
line segments or bilinear patches. The same is, of course, true when
- integrating boundary terms (e.g., inhomogenous Neumann boundary
+ integrating boundary terms (e.g., inhomogeneous Neumann boundary
conditions). For the purpose of integration, the various Mapping classes
then provide the transformation from the reference cell to the actual cell.
In this program, we will consider a test case where the exact pressure
is $p = \sin \left( \pi x\right)\sin\left(\pi y \right)$ on the unit square domain,
-with homogenous Dirichelet boundary conditions and $\mathbf{K}$ the identity matrix.
+with homogeneous Dirichelet boundary conditions and $\mathbf{K}$ the identity matrix.
Then we will calculate $L_2$ errors of pressure, velocity, and flux.
<h1>Results</h1>
-We run the test example $p = \sin(\pi x) \sin(\pi y)$ with homogenous Dirichelet
+We run the test example $p = \sin(\pi x) \sin(\pi y)$ with homogeneous Dirichelet
boundary conditions in the domain $\Omega = (0,1)^2$. And $\mathbf{K}$ is the
identity matrix. We test it on $\mbox{WG}(Q_0,Q_0;RT_{[0]})$, $\mbox{WG}(Q_1,Q_1;RT_{[1]})$
and $\mbox{WG}(Q_2,Q_2;RT_{[2]})$. We will visualize pressure values in interiors
//
// We will show here how the library managed to find out that there are
// still active references to an object and the object is still alive
- // frome the point of view of a using object. Basically, the method is along
+ // from the point of view of a using object. Basically, the method is along
// the following line: all objects that are subject to such potentially
// dangerous pointers are derived from a class called Subscriptor. For
// example, the Triangulation, DoFHandler, and a base class of the
* = *ptr_to_some_number; // Invalid call
* @endcode
*
- * Similar to the first example, we must be concious of the fact that the
+ * Similar to the first example, we must be conscious of the fact that the
* copies of any @p Type stored by @p data only remains valid while the
* GeneralDataStorage instance in which it is stored is alive.
*
const unsigned int selected;
/**
- * Flag that controls wether we rescale the value when the radius changes.
+ * Flag that controls whether we rescale the value when the radius changes.
*/
bool integrate_to_one;
const bool integrate_to_one = false);
/**
- * Initialize the class with an objet of type
+ * Initialize the class with an object of type
* @tparam CutOffFunctionBaseType<1>.
*/
template <template <int> class CutOffFunctionBaseType>
};
/**
* This constructor creates or opens a group depending on the value of
- * @p mode. The group will be placed insided the group @p parent_group. The
+ * @p mode. The group will be placed inside the group @p parent_group. The
* parameter @p mpi defines if the the I/O operations are serial or
* parallel. This is an internal constructor, the functions open_group() and
* create_group() of the current class should be used to open or create a
eig_vals_vecs[1].second /= eig_vals_vecs[1].second.norm();
// If vectors are nearly linearly dependent, or if there might have
- // been large cancelations in the calculation of A[i][i] - w[0], fall
+ // been large cancellations in the calculation of A[i][i] - w[0], fall
// back to QL algorithm
if (eig_vals_vecs[0].second * eig_vals_vecs[1].second > error)
{
reset(const bool clear_registered_tapes);
/**
- * Print the status of all queriable data. Exactly what is printed and
+ * Print 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.
*
"that the component offsets used to construct their counterpart "
"extractors are incompatible with one another. Make sure that "
"the first component for each extractor properly takes into "
- "account the dimensionality of the preceeding fields."));
+ "account the dimensionality of the preceding fields."));
}
# endif
set_independent_variable(value, extractor);
* This constructor initializes a symbolic type with a string
* representing its symbolic value.
* If the @p parse_as_expression flag is <tt>false</tt>, then the
- * @p symb_expr (potentially composed of mulitple characters) will be
+ * @p symb_expr (potentially composed of multiple characters) will be
* interpreted as a single symbol.
* If the @p parse_as_expression flag is <tt>true</tt>, then the
* @p symb_expr will be parsed as a symbolic expression (potentially
* For example, if the @p symbol is the string `"x"` then the scalar
* symbolic variable that is returned represents the scalar $x$.
*
- * @param[in] symbol An indentifier (or name) for the returned symbolic
+ * @param[in] symbol An identifier (or name) for the returned symbolic
* variable.
* @return A scalar symbolic variable with the name @p symbol.
*
* symbolic variable `x` and the symbolic expression `y+z`, then the
* generic symbolic function that is returned represents $f(x, y+z)$.
*
- * @param[in] symbol An indentifier (or name) for the returned symbolic
+ * @param[in] symbol An identifier (or name) for the returned symbolic
* function.
* @param[in] arguments A vector of input arguments to the returned
* symbolic function.
* symbolic variable `x` and the symbolic expression `y+z`, then the
* generic symbolic function that is returned represents $f(x, y+z)$.
*
- * @param[in] symbol An indentifier (or name) for the returned symbolic
+ * @param[in] symbol An identifier (or name) for the returned symbolic
* function.
* @param[in] arguments A map of input arguments to the returned
* symbolic function.
* indicates its component index.
*
* @tparam dim The dimension of the returned tensor.
- * @param[in] symbol An indentifier (or name) for the vector of returned
+ * @param[in] symbol An identifier (or name) for the vector of returned
* symbolic variables.
* @return A vector (a rank-1 tensor) of symbolic variables with the name of
* each individual component prefixed by @p symbol.
*
* @tparam rank The rank of the returned tensor.
* @tparam dim The dimension of the returned tensor.
- * @param[in] symbol An indentifier (or name) for the tensor of returned
+ * @param[in] symbol An identifier (or name) for the tensor of returned
* symbolic variables.
* @return A tensor of symbolic variables with the name of each individual
* component prefixed by @p symbol.
*
* @tparam rank The rank of the returned tensor.
* @tparam dim The dimension of the returned tensor.
- * @param[in] symbol An indentifier (or name) for the tensor of returned
+ * @param[in] symbol An identifier (or name) for the tensor of returned
* symbolic variables.
* @return A tensor of symbolic variables with the name of each individual
* component prefixed by @p symbol.
* @p arguments map; the values stored in the map are ignored.
*
* @tparam dim The dimension of the returned tensor.
- * @param[in] symbol An indentifier (or name) for the vector of returned
+ * @param[in] symbol An identifier (or name) for the vector of returned
* symbolic functions.
* @param[in] arguments A map of input arguments to the returned
* symbolic functions.
*
* @tparam rank The rank of the returned tensor.
* @tparam dim The dimension of the returned tensor.
- * @param[in] symbol An indentifier (or name) for the tensor of returned
+ * @param[in] symbol An identifier (or name) for the tensor of returned
* symbolic functions.
* @param[in] arguments A map of input arguments to the returned
* symbolic functions.
*
* @tparam rank The rank of the returned tensor.
* @tparam dim The dimension of the returned tensor.
- * @param[in] symbol An indentifier (or name) for the tensor of returned
+ * @param[in] symbol An identifier (or name) for the tensor of returned
* symbolic functions.
* @param[in] arguments A map of input arguments to the returned
* symbolic functions.
/**
* Extract the symbols (key entries) from a substitution map.
*
- * @note It is guarenteed that the order of extraction of data into the
+ * @note It is guaranteed that the order of extraction of data into the
* output vector is the same as that for extract_values().
* That is to say that the unzipped key and value pairs as given by
* extract_symbols() and extract_values() always have a 1:1
* The value entries will be converted into the @p NumberType given
* as a template parameter to this function via the @p ExpressionType.
*
- * @note It is guarenteed that the order of extraction of data into the
+ * @note It is guaranteed that the order of extraction of data into the
* output vector is the same as that for extract_symbols().
* That is to say that the unzipped key and value pairs as given by
* extract_symbols() and extract_values() always have a 1:1
* associated with vertices are not stored in the DoFObjects classes but
* rather in the DoFHandler::vertex_dofs array.
*
- * The DoFObjects classes are not used directly, but objects of theses
+ * The DoFObjects classes are not used directly, but objects of these
* classes are included in the DoFLevel and DoFFaces classes.
*
* @ingroup dofs
*
* In some cases, one wants to only work with DoFs that sit on the boundary.
* One application is, for example, if rather than interpolating non-
- * homogenous boundary values, one would like to project them. For this, we
+ * homogeneous boundary values, one would like to project them. For this, we
* need two things: a way to identify nodes that are located on (parts of) the
* boundary, and a way to build matrices out of only degrees of freedom that
* are on the boundary (i.e. much smaller matrices, in which we do not even
* in ${\cal V}_1$ since by construction ${\cal V}_0 \subset {\cal V}_1$.
* However, not every function in ${\cal V}_1$ can be expressed as a linear
* combination of the shape functions of ${\cal V}_0$. The functions that
- * can be represented lie in a homogenous subspace of ${\cal V}_1$ (namely,
+ * can be represented lie in a homogeneous subspace of ${\cal V}_1$ (namely,
* ${\cal V}_0$, of course) and this subspace can be represented by a linear
* constraint of the form $CV=0$ where $V$ is the vector of nodal values of
* functions $v\in {\cal V}_1$. In other words, every function $v_h=\sum_j
const unsigned int dofs_per_cell = Utilities::fixed_power<dim>(n);
- // Assert size maches degree
+ // Assert size matches degree
AssertDimension(h2l.size(), dofs_per_cell);
// polynomial degree
/**
* Elliptical manifold description derived from ChartManifold.
- * More informations on the elliptical coordinate system can be found
+ * More information on the elliptical coordinate system can be found
* at <a
* href="https://en.wikipedia.org/wiki/Elliptic_coordinate_system">Wikipedia
* </a>.
* succeeding finite elements for refinement and preceding ones for
* coarsening.
*
- * In this struct, we supply a hierachy that is imposed on all FECollection
+ * In this struct, we supply a hierarchy that is imposed on all FECollection
* objects by default.
*/
struct DefaultHierarchy
* Here, the numerical flux $\widehat u$ is the upwind value at the face,
* namely the finite element function whose values are given in the
* argument `input` on the outflow boundary. On the inflow boundary, it is
- * the inhomogenous boundary value in the argument `data`.
+ * the inhomogeneous boundary value in the argument `data`.
*
* The <tt>velocity</tt> is provided as an ArrayView, having <tt>dim</tt>
* vectors, one for each velocity component. Each of the vectors must
* Here, the numerical flux $\widehat u$ is the upwind value at the face,
* namely the finite element function whose values are given in the
* argument `input` on the outflow boundary. On the inflow boundary, it is
- * the inhomogenous boundary value in the argument `data`.
+ * the inhomogeneous boundary value in the argument `data`.
*
* The <tt>velocity</tt> is provided as an ArrayView, having <tt>dim</tt>
* vectors, one for each velocity component. Each of the vectors must
{
/**
* A data type in which we store the list of entries that make up the
- * homogenous part of a constraint.
+ * homogeneous part of a constraint.
*/
using Entries = std::vector<std::pair<size_type, number>>;
/**
* Reference to the object that controls convergence of the iterative
* solver. In fact, for these CUDA wrappers, cuSOLVER and cuSPARSE do so
- * themselve, but we copy the data from this object before starting the
+ * themselves, but we copy the data from this object before starting the
* solution process, and copy the data back into it afterwards.
*/
SolverControl &solver_control;
trilinos_vector() const;
/**
- * Return a (modifyable) reference to the underlying Trilinos
+ * Return a (modifiable) reference to the underlying Trilinos
* Tpetra::Vector class.
*/
Tpetra::Vector<Number, int, types::global_dof_index> &
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)
{
// The element is placed in the 'first position' along *-axis. These also
// determine which face is constrained. For example, in 2D, if
- // constr_face_x and constr_type are set, then x = 0 is contrained.
+ // constr_face_x and constr_type are set, then x = 0 is constrained.
constexpr unsigned int constr_type_x = 1 << 0;
constexpr unsigned int constr_type_y = 1 << 1;
constexpr unsigned int constr_type_z = 1 << 2;
*
* Similarly, the methods in @ref NeighborCellMethods initialize on demand
* (different) internal FEValues, FEFaceValues, and FESubfaceValues, on
- * neighbor cells, allowing the use of this class aslo as a single substitute
+ * neighbor cells, allowing the use of this class also as a single substitute
* for the additional three objects you would typically need to integrate on
* the neighbor cell, and on its faces and subfaces (for example, in
* discontinuous Galerkin methods).
// the terminal, of the form
// ADOL-C error: reading integer tape number 4!
// >>> File or directory not found! <<<
- // , every time a query is made about a non-existant tape.
+ // , every time a query is made about a non-existent tape.
// So either way we have to guard that check with something more
// conervative so that we don't output useless messages for our users.
const std::vector<typename Types<ADNumberType>::tape_index>
const auto it_status_tape = status.find(tape_index);
// This tape's status has not been found in the map. This could be
- // because a non-existant tape_index has been used as an argument, or
+ // because a non-existent tape_index has been used as an argument, or
// because the tape exists but has not been used (in a way that
// initiated a status update). For example, on can create a tape in one
// section of code and then query the status of all existing tapes in a
++face)
{
// cell shouldn't be at the boundary and
- // neigboring cell is not already visited (to avoid visiting
+ // neighboring cell is not already visited (to avoid visiting
// same face twice). Note that the cells' material ids are
// labeled according to their order in dof_handler previously.
if (!cell->at_boundary(face) &&
0,
false);
// for parallel::shared::Triangulation we need to work on all vertices,
- // not just the ones related to loacally owned cells;
+ // not just the ones related to locally owned cells;
const bool is_parallel_shared =
(dynamic_cast<parallel::shared::Triangulation<dim, spacedim> *>(
&triangulation) != nullptr);
row_ptr_dev.get(),
row_sums.get_values());
-# ifdef DEUG
+# ifdef DEBUG
// Check that the kernel was launched correctly
AssertCuda(cudaGetLastError());
// Check that there was no problem during the execution of the kernel
boost::geometry::index::intersects(bbox),
std::back_inserter(out_vals));
// Each bounding box corresponds to an active cell
- // of the imbedding triangulation: we now check if
- // the current cell, of the imbedded triangulation,
- // overlaps a locally owned cell of the imbedding one
+ // of the embedding triangulation: we now check if
+ // the current cell, of the embedded triangulation,
+ // overlaps a locally owned cell of the embedding one
for (const auto &bbox_it : out_vals)
if (bbox_it.second->is_locally_owned())
{
}
{
- deallog << "Checking move assignement" << std::endl;
+ deallog << "Checking move assignment" << std::endl;
Subscriptor subscriptor_1;
Subscriptor subscriptor_2;
DEAL::Checking copy construction
DEAL::Checking smart_pointer_1
DEAL::
-DEAL::Checking move assignement
+DEAL::Checking move assignment
DEAL::Checking smart_pointer_1
DEAL::ExcMessage("The object pointed to is not valid anymore.")
DEAL::Checking smart_pointer_2
return static_cast<Number>(std::complex<float>(1, 1));
}
-// This function assignes data to the elements of the container
+// This function assigns data to the elements of the container
template <template <class...> class Container, typename Number>
typename std::enable_if<
std::is_same<Container<Number>, std::vector<Number>>::value,
return static_cast<Number>(std::complex<float>(1, 1));
}
-// This function assignes data to the elements of the container
+// This function assigns data to the elements of the container
template <template <class...> class Container, typename Number>
typename std::enable_if<
std::is_same<Container<Number>, std::vector<Number>>::value,
-// This function assignes data to the elements of the container
+// This function assigns data to the elements of the container
template <template <class...> class Container, typename Number>
typename std::enable_if<
std::is_same<Container<Number>, std::vector<Number>>::value,
-// This function assignes data to the elements of the container
+// This function assigns data to the elements of the container
template <template <class...> class Container, typename Number>
typename std::enable_if<
std::is_same<Container<Number>, std::vector<Number>>::value,
// ---------------------------------------------------------------------
-// check that we detect creating ArrayView objects wit the wrong memory space.
+// check that we detect creating ArrayView objects with the wrong memory space.
#include <deal.II/base/array_view.h>
// read in a Triangulation<2,3> from a mesh file writtent in the UCD format
-// the meshe used here were generated by Andrea Mola
+// the meshes used here were generated by Andrea Mola
#include <deal.II/dofs/dof_handler.h>
matrix.reinit(dsp);
vector.reinit(partitioning);
- // Assemble system: Mass matrix and constrant RHS vector
+ // Assemble system: Mass matrix and constraint RHS vector
FEValues<dim> fe_values(fe,
quadrature_formula,
update_values | update_JxW_values);
matrix.reinit(dsp);
vector.reinit(locally_owned_partitioning, mpi_communicator);
- // Assemble system: Mass matrix and constrant RHS vector
+ // Assemble system: Mass matrix and constraint RHS vector
FEValues<dim> fe_values(fe,
quadrature_formula,
update_values | update_JxW_values);
// Test the correct handling of data members within the TensorProductManifold
// class. The test generates a general hypercube grid and, in an inner scope,
-// attempts to assign a TensorProductManifold to it. The test is succesfull if
+// attempts to assign a TensorProductManifold to it. The test is successful if
// it terminates without subscriptor errors or memory leaks.
#include <deal.II/grid/grid_generator.h>
// We check if active_fe_indices are set correctly
// before and after coarsening and refinement.
//
-// We use a parallel::share::Triangulation that allows artifical cells.
+// We use a parallel::share::Triangulation that allows artificial cells.
//
// This test is inspired by 'mpi/hp_active_fe_indices_transfer_01.cc'.
cell->set_refine_flag();
}
- // and atleast one cell:
+ // and at least one cell:
if (!locals)
{
for (typename Triangulation<dim>::active_cell_iterator cell =
// Here (in a most inefficient way) we check the effect of
// taking the proposed Newton step, and adjust it using
- // the line-search algorith.
+ // the line-search algorithm.
// Previous step residual
BlockVector<double> residual_0 = this->system_rhs;
{
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
{
- // Standard intialiser...
+ // Standard initialiser...
PETScWrappers::FullMatrix m(3, 3);
test(m);
}
// By default, all the ranks will try to access the device 0.
// If we are running with MPI support it is better to address different graphic
// cards for different processes even if only one node is used. The choice below
-// is based on the MPI proccess id.
+// is based on the MPI process id.
// MPI needs to be initialized before using this function.
void
init_cuda(const bool use_mpi = false)
projects / dealii.git / commitdiff