" face with the given face number face_no. Ideally the point is \n"
" near the face face_no, but any point in the cell can technically \n"
" be projected. The returned point is of dimension dim with \n"
- " dim-1 coodinate value explicitly set to zero. \n";
+ " dim-1 coordinate value explicitly set to zero. \n";
void
"with respect to the origin. Additional points are sums of these dim \n"
"vectors. Colorizing is done according to hyper_rectangle(). \n"
"Note: This function silently reorders the vertices on the cells to \n"
- "lexicographic ordering (see GridReordering::reoder_grid()). In other \n"
- "words, if reordering of the vertices does occur, the ordering of \n"
+ "lexicographic ordering (see GridTools::consistently_order_cells()). In \n"
+ "other words, if reordering of the vertices does occur, the ordering of \n"
"vertices in the array of corners will no longer refer to the same \n"
"triangulation. \n";
AssertThrow(
spacedim == dim,
ExcMessage(
- "This function is only implementd for dim equal to spacedim."));
+ "This function is only implemented for dim equal to spacedim."));
// Extract the PointWrapper object from the python list
const int size = boost::python::len(vertices);
AssertThrow(size > 0, ExcMessage("The vertices list is empty."));
else
AssertThrow(false,
ExcMessage(
- "Thie combination of dim-spacedim is not supported."));
+ "This combination of dim-spacedim is not supported."));
}
# Blocks (some) threads until all the threads finished their tasks.
# Works similar to MPI_Barrier().
# In other words, threads wait until all the tasks in task_queue
- # have finshed.
+ # have finished.
#
task_queue.join()
-Fixed: The function ParamerHandler::add_parameter() used to
+Fixed: The function ParameterHandler::add_parameter() used to
call the internal action. Within that step, the action
converts the default value to a string and back afterwards.
This can lead to round-off errors so that the default
values might change in the case of floating-point numbers.
-The action is not called any more during ParamerHandler::add_parameter(),
+The action is not called any more during ParameterHandler::add_parameter(),
fixing the problem.
<br>
(Peter Munch, Magdalena Schreter, 2022/12/11)
-Extensive rework of CUDAWrappers::MatrixFree and CUDAWrappers::FEEvalution.
+Extensive rework of CUDAWrappers::MatrixFree and CUDAWrappers::FEEvaluation.
<br>
(Bruno Turcksin, 2023/05/11)
Improved: Introduce a function that only checks if Bounding Boxes are overlapping.
-Fixed: If a 1D BBox is completely contained in another one, it was not recognized as mergable neighbor.
+Fixed: If a 1D BBox is completely contained in another one, it was not recognized as mergeable neighbor.
<br>
(Johannes Heinz, 2022/07/07)
latter case first for further background information on the topic, and
then come back to this tutorial to try out your newly acquired skills.
-We go one step further in step-75: Here, we combine hp-adapative and
+We go one step further in step-75: Here, we combine hp-adaptive and
MatrixFree methods in combination with
parallel::distributed::Triangulation objects.
// Defined in these two headers are some operations that are pertinent to
// finite strain elasticity. The first will help us compute some kinematic
-// quantities, and the second provides some stanard tensor definitions.
+// quantities, and the second provides some standard tensor definitions.
#include <deal.II/physics/elasticity/kinematics.h>
#include <deal.II/physics/elasticity/standard_tensors.h>
use on the $L$-shaped domain of the current program, these sizes are
$21\times 21$ in 2d and $117\times 117$ in 3d. But if the coarse mesh
consists of hundreds or thousands of cells, this approach will no
-longer work and might start to dominate the overall run-time of each V-cyle.
+longer work and might start to dominate the overall run-time of each V-cycle.
A common approach is then to solve the coarse mesh problem using an
algebraic multigrid preconditioner; this would then, however, require
assembling the coarse matrix (even for the matrix-free version) as
// This function has two parts in the integration loop: applying the negative
// of matrix $A$ to $u_0$ by submitting the negative of the gradient, and adding
// the right-hand side contribution by submitting the value $f$. We must be sure
-// to use `read_dof_values_plain()` for evaluating $u_0$ as `read_dof_vaues()`
+// to use `read_dof_values_plain()` for evaluating $u_0$ as `read_dof_values()`
// would set all Dirichlet values to zero.
//
// Finally, the system_rhs vector is of type LA::MPI::Vector, but the
Solving this becomes expensive, however: The simulation was done with
1,817 million degrees of freedom (continuous $Q_1$ finite elements)
per component (for a total of 9.09 billion spatial degrees of freedom)
-and ran on 30,720 MPI ranks. The code achieved an average througput of
+and ran on 30,720 MPI ranks. The code achieved an average throughput of
969M grid points per second (0.04M gridpoints per second per CPU). The
front and back wall show a "Schlieren plot": the magnitude of the
gradient of the density on an exponential scale from white (low) to
// neighboring <code>neighbor_cell</code> of <code>cell</code>, namely we
// fill-in the variable <code>discrete_hessians_neigh[face_no][i][q]</code>.
// For the lifting terms, we only need to add the contribution of the
- // face adjecent to <code>cell</code> and <code>neighbor_cell</code>.
+ // face adjacent to <code>cell</code> and <code>neighbor_cell</code>.
for (unsigned int face_no = 0; face_no < cell->n_faces(); ++face_no)
{
const typename DoFHandler<dim>::face_iterator face =
/*
* This sets the largest number of vectorization bits detected for the given
* compiler flags and hardware (e.g. 256 for AVX on x86-64 architectures) for
- * use in deal.II's instrinsics-based VectorizedArray class.
+ * use in deal.II's intrinsics-based VectorizedArray class.
*/
#define DEAL_II_VECTORIZATION_WIDTH_IN_BITS @DEAL_II_VECTORIZATION_WIDTH_IN_BITS@
protected:
/**
- * Name of the HDF5Oject. In the case of File, @p name corresponds to the
+ * Name of the HDF5Object. In the case of File, @p name corresponds to the
* file name. In the case of Group and DataSet @p name corresponds to the
* name of the object in the HDF5 file.
*/
* @note This function performs a single reduction sweep.
*
* @pre Size of the input ArrayView has to be the same on all processes
- * and the input and output ArrayVew have to have the same size.
+ * and the input and output ArrayView have to have the same size.
*/
void
min_max_avg(const ArrayView<const double> &my_values,
* By calling the method add_parameters() passing a ParameterHandler object,
* the following options will be defined in the given ParameterHandler object
* (in the current level of the ParameterHandler object, i.e., whatever level
- * you have entered with the ParamterHandler::enter_subsection() method),
+ * you have entered with the ParameterHandler::enter_subsection() method),
* and can be modified at run time through a parameter file:
* @code
* set Enable computation of the errors = true
AssertThrow(
F.size() == 0,
ExcMessage(
- "RungeKutta methods cannot handle more that one function to integate."));
+ "RungeKutta methods cannot handle more that one function to integrate."));
AssertThrow(
J_inverse.size() == 0,
ExcMessage(
- "RungeKutta methods cannot handle more that one function to integate."));
+ "RungeKutta methods cannot handle more that one function to integrate."));
return evolve_one_time_step(F[0], J_inverse[0], t, delta_t, y);
}
const unsigned int n_chunks = n_entries / 4;
// To avoid warnings about uninitialized variables, need to initialize one
- // variable to a pre-exisiting value in out, which will never get used in
+ // variable to a pre-existing value in out, which will never get used in
// the end. Keep the initialization outside the loop because of a bug in
// gcc-9.1 which generates a "vmovapd" instruction instead of "vmovupd" in
// case t3 is initialized to zero (inside/outside of loop), see
std::vector<double> norm_values;
// first, parse all table elements into a map of predicate values and
- // coefficients. We could have stored (predicate values ->TableIndicies) map,
+ // coefficients. We could have stored (predicate values ->TableIndices) map,
// but its processing would have been much harder later on.
std::map<unsigned int, std::vector<CoefficientType>> pred_to_values;
internal::FESeriesImplementation::fill_map(coefficients,
* with M>N unknowns is well-defined, but often yields funny and non-
* intuitive results. Secondly, one would think that if the quadrature point
* data is defined in the support points of the finite element, i.e. the
- * quadrature points of <tt>ths_quadrature</tt> equal
+ * quadrature points of <tt>rhs_quadrature</tt> equal
* <tt>fe.get_unit_support_points()</tt>, then the projection should be the
* identity, i.e. each degree of freedom of the finite element equals the
* value of the given data in the support point of the corresponding shape
* values of A. V is a NxN orthonal matrix containing the right singular
* vectors corresponding the singular values of A.
*
- * Note that the variable #svd_vt contains the tranpose of V and can be
+ * Note that the variable #svd_vt contains the transpose of V and can be
* accessed by get_svd_vt(), while U is accessed with get_svd_u().
*/
void
Tvmult(VectorBase &dst, const VectorBase &src) const;
/**
- * Explictly call setup. This is usually not needed since PETSc will
+ * Explicitly call setup. This is usually not needed since PETSc will
* automatically call the setup function when needed.
*/
void
* vectors. The residual sum of squares for each column is given by the sum of
* squares of elements $M$ to $N-1$ in that column.
*
- * If(!tranpose) then $\mathbf{B} \in \mathbb{R}^{M \times N_{\rm RHS}}$,
+ * If(!transpose) then $\mathbf{B} \in \mathbb{R}^{M \times N_{\rm RHS}}$,
* otherwise $\mathbf{B} \in \mathbb{R}^{N \times N_{\rm RHS}}$.
* The matrices $\mathbf{A}$ and $\mathbf{B}$ must have an identical block
* cyclic distribution for rows and columns.
!is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
double
- substract_and_norm(
+ subtract_and_norm(
const unsigned int dim,
const internal::SolverGMRESImplementation::TmpVectors<VectorType>
& orthogonal_vectors,
is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
double
- substract_and_norm(
+ subtract_and_norm(
const unsigned int dim,
const internal::SolverGMRESImplementation::TmpVectors<VectorType>
& orthogonal_vectors,
classical_gram_schmidt)
{
Tvmult_add(dim, vv, orthogonal_vectors, h);
- norm_vv = substract_and_norm(dim, orthogonal_vectors, h, vv);
+ norm_vv = subtract_and_norm(dim, orthogonal_vectors, h, vv);
}
else
{
* the function DoFAccessor::get_interpolated_dof_values when no
* constraints are present, but it also includes constraints from hanging
* nodes, so once can see it as a similar function to
- * AffineConstraints::read_dof_valuess as well.
+ * AffineConstraints::read_dof_values() as well.
*/
DEAL_II_HOST_DEVICE void
read_dof_values(const Number *src);
* write to vectors in parallel without having to explicitly synchronize
* access to these vectors and matrices. This class does not implement any
* shape values, all it does is to cache the respective data. To implement
- * finite element operations, use the class CUDAWrappers::FEEvalutation.
+ * finite element operations, use the class CUDAWrappers::FEEvaluation.
*
* This class traverse the cells in a different order than the usual
* Triangulation class in deal.II.
* To be able to evaluate all face integrals (with values or gradients
* from the neighboring cells), all ghost values from neighboring cells are
* updated. Use
- * FEFaceEvalution::reinit(cell, face_no) to access quantities on arbitrary
+ * FEFaceEvaluation::reinit(cell, face_no) to access quantities on arbitrary
* faces of a cell and the respective neighbors.
*
* @param cell_operation Pointer to member function of `CLASS` with the
std::vector<Point<dim>> points;
points.resize(local_support_point_indices.size());
- const auto locally_onwed_support_point =
+ const auto locally_owned_support_point =
dof_handler_support_points->locally_owned_dofs();
std::vector<unsigned int> indices_state(
- locally_onwed_support_point.n_elements(),
+ locally_owned_support_point.n_elements(),
numbers::invalid_unsigned_int);
AssertIndexRange(local_support_point_indices.size(),
cell->get_dof_indices(dof_indices);
for (const unsigned int q : fe_values.quadrature_point_indices())
- if (locally_onwed_support_point.is_element(dof_indices[q]))
+ if (locally_owned_support_point.is_element(dof_indices[q]))
{
const auto index =
- locally_onwed_support_point.index_within_set(dof_indices[q]);
+ locally_owned_support_point.index_within_set(dof_indices[q]);
if (indices_state[index] != numbers::invalid_unsigned_int)
{
inline std::vector<Point<2>>
generate_simplex_evaluation_points(const unsigned int n_subdivisions)
{
- std::vector<Point<2>> evalution_points;
+ std::vector<Point<2>> evaluation_points;
generate_simplex_evaluation_points_recursively(
{{Point<2>(0.0, 0.0), Point<2>(1.0, 0.0), Point<2>(0.0, 1.0)}},
n_subdivisions,
- evalution_points);
+ evaluation_points);
- return evalution_points;
+ return evaluation_points;
}
/**
* Implements the visitor interface for InternalNode objects. If the node
- * belongs to the @p target_leve, then fill the bounding box vector.
+ * belongs to the @p target_level, then fill the bounding box vector.
*/
inline void
operator()(InternalNode const &node);
ExtractLevelVisitor<Value, Options, Translator, Box, Allocators>::operator()(
const ExtractLevelVisitor::InternalNode &node)
{
- using ElmentsType =
+ using ElementsType =
typename boost::geometry::index::detail::rtree::elements_type<
InternalNode>::type;
boxes.resize(offset + elements.size());
unsigned int i = offset;
- for (typename ElmentsType::const_iterator it = elements.begin();
+ for (typename ElementsType::const_iterator it = elements.begin();
it != elements.end();
++it)
{
const size_t level_backup = level;
++level;
- for (typename ElmentsType::const_iterator it = elements.begin();
+ for (typename ElementsType::const_iterator it = elements.begin();
it != elements.end();
++it)
{
#
# Automatically add the current source and binary directory as include
-# directory. The binary directory is needed in order to find the expaned
+# directory. The binary directory is needed in order to find the expanded
# .inst include files.
#
set(CMAKE_INCLUDE_CURRENT_DIR true)
#
# Define a "dealii", i.e., "${DEAL_II_TARGET_NAME}", target that contains
-# DEAL_II_CXX_FLAGS[_DEBUG|_RELEASE] and otherwsie aliases dealii_debug or
+# DEAL_II_CXX_FLAGS[_DEBUG|_RELEASE] and otherwise aliases dealii_debug or
# dealii_release depending on the downstream CMAKE_BUILD_TYPE.
#
float max_color_value = std::numeric_limits<float>::min();
// Array for z-coordinates of points. The elevation determined by a function
- // if spacedim=2 or the z-cooridate of the grid point if spacedim=3
+ // if spacedim=2 or the z-coordinate of the grid point if spacedim=3
double heights[4] = {0, 0, 0, 0};
// compute the cells for output and enter them into the set above note that
// next set up a table for the degrees of freedom on each of the cells
// whether it is something interesting or not
- std::vector<unsigned char> local_component_asssociation =
+ std::vector<unsigned char> local_component_association =
internal::get_local_component_association(fe, component_mask);
std::vector<bool> local_selected_dofs(fe.n_dofs_per_cell());
for (unsigned int i = 0; i < fe.n_dofs_per_cell(); ++i)
- local_selected_dofs[i] = component_mask[local_component_asssociation[i]];
+ local_selected_dofs[i] = component_mask[local_component_association[i]];
// then loop over all cells and do work
std::vector<types::global_dof_index> indices(fe.n_dofs_per_cell());
std::string
FE_DGNedelec<dim, spacedim>::get_name() const
{
- // note that the FETools::get_fe_by_nam function depends on the
+ // note that FETools::get_fe_by_name() depends on the
// particular format of the string
// this function returns, so they
// have to be kept in synch
const double alpha = bias_alpha(1 - (1.0 * iy) / n_cells_y);
// define points on upper/lower horizontal far field side,
// i.e. face DG or FI. Incline factor to move points G and I
- // to the right by distance incline_facor*lenght_b2
+ // to the right by distance incline_factor*length_b2
const Point<2> p(ix * dx + center_mesh +
incline_factor * length_b2 * ix /
n_cells_x_1,
Assert(row_block_size == column_block_size,
ExcDimensionMismatch(row_block_size, column_block_size));
- const bool left_singluar_vectors = (U != nullptr) ? true : false;
- const bool right_singluar_vectors = (VT != nullptr) ? true : false;
+ const bool left_singular_vectors = (U != nullptr) ? true : false;
+ const bool right_singular_vectors = (VT != nullptr) ? true : false;
- if (left_singluar_vectors)
+ if (left_singular_vectors)
{
Assert(n_rows == U->n_rows, ExcDimensionMismatch(n_rows, U->n_rows));
Assert(U->n_rows == U->n_columns,
Assert(grid->blacs_context == U->grid->blacs_context,
ExcDimensionMismatch(grid->blacs_context, U->grid->blacs_context));
}
- if (right_singluar_vectors)
+ if (right_singular_vectors)
{
Assert(n_columns == VT->n_rows,
ExcDimensionMismatch(n_columns, VT->n_rows));
if (grid->mpi_process_is_active)
{
- char jobu = left_singluar_vectors ? 'V' : 'N';
- char jobvt = right_singluar_vectors ? 'V' : 'N';
+ char jobu = left_singular_vectors ? 'V' : 'N';
+ char jobvt = right_singular_vectors ? 'V' : 'N';
NumberType *A_loc = this->values.data();
- NumberType *U_loc = left_singluar_vectors ? U->values.data() : nullptr;
- NumberType *VT_loc = right_singluar_vectors ? VT->values.data() : nullptr;
+ NumberType *U_loc = left_singular_vectors ? U->values.data() : nullptr;
+ NumberType *VT_loc = right_singular_vectors ? VT->values.data() : nullptr;
int info = 0;
/*
* by setting lwork to -1 a workspace query for optimal length of work is
const std::vector<types::global_dof_index> &n_cells_on_levels,
const MPI_Comm comm)
{
- std::vector<types::global_dof_index> n_cells_on_leves_max(
+ std::vector<types::global_dof_index> n_cells_on_levels_max(
n_cells_on_levels.size());
- std::vector<types::global_dof_index> n_cells_on_leves_sum(
+ std::vector<types::global_dof_index> n_cells_on_levels_sum(
n_cells_on_levels.size());
- Utilities::MPI::max(n_cells_on_levels, comm, n_cells_on_leves_max);
- Utilities::MPI::sum(n_cells_on_levels, comm, n_cells_on_leves_sum);
+ Utilities::MPI::max(n_cells_on_levels, comm, n_cells_on_levels_max);
+ Utilities::MPI::sum(n_cells_on_levels, comm, n_cells_on_levels_sum);
const unsigned int n_proc = Utilities::MPI::n_mpi_processes(comm);
- const double ideal_work = std::accumulate(n_cells_on_leves_sum.begin(),
- n_cells_on_leves_sum.end(),
+ const double ideal_work = std::accumulate(n_cells_on_levels_sum.begin(),
+ n_cells_on_levels_sum.end(),
0) /
static_cast<double>(n_proc);
const double workload_imbalance =
- std::accumulate(n_cells_on_leves_max.begin(),
- n_cells_on_leves_max.end(),
+ std::accumulate(n_cells_on_levels_max.begin(),
+ n_cells_on_levels_max.end(),
0) /
ideal_work;
* FESeries::process_coefficients() which requires a predicate to be
* specified. The predicate should operate on TableIndices and return a
* pair of <code>bool</code> and <code>unsigned int</code>. The latter is
- * the value of the map from TableIndicies to unsigned int. It is used to
+ * the value of the map from TableIndices to unsigned int. It is used to
* define subsets of coefficients from which we search for the one with
* highest absolute value, i.e. $l^\infty$-norm. The <code>bool</code>
* parameter defines which indices should be used in processing. In the
* which requires a predicate to be specified. The predicate should
* operate on TableIndices and return a pair of <code>bool</code> and
* <code>unsigned int</code>. The latter is the value of the map from
- * TableIndicies to unsigned int. It is used to define subsets of
+ * TableIndices to unsigned int. It is used to define subsets of
* coefficients from which we search for the one with highest absolute
* value, i.e. $l^\infty$-norm. The <code>bool</code> parameter defines
* which indices should be used in processing. In the current case we are
projects / dealii.git / commitdiff