--- /dev/null
+name: Spell Check with Typos
+on:
+ push:
+ branches:
+ - 'master'
+ pull_request:
+
+concurrency:
+ group: ${{ github.actor }}-${{ github.ref }}-typos
+ cancel-in-progress: true
+
+permissions: write-all
+
+jobs:
+ typos-check:
+ name: Check for new typos
+ runs-on: ubuntu-latest
+ timeout-minutes: 5
+ steps:
+ - name: Checkout the Checkout Actions Repository
+ uses: actions/checkout@v4
+ with:
+ persist-credentials: false
+ - name: Check spelling with typos
+ env:
+ GH_TOKEN: "${{ github.token }}"
+ run: |
+ mkdir -p "${{ runner.temp }}/typos"
+ wget --secure-protocol=TLSv1_3 --max-redirect=1 --retry-on-host-error --retry-connrefused --tries=3 \
+ --quiet --output-document=- "https://github.com/crate-ci/typos/releases/download/v1.19.0/typos-v1.19.0-x86_64-unknown-linux-musl.tar.gz" \
+ | tar -xz -C "${{ runner.temp }}/typos" ./typos
+ "${{ runner.temp }}/typos/typos" --version
+
+ "${{ runner.temp }}/typos/typos" --config .typos.toml --format json doc examples include source tests >> ${{ runner.temp }}/typos.jsonl || true
+ - name: Update repo with fixable typos
+ uses: crate-ci/typos@v1.19.0
+ with:
+ write_changes: true
+ config: ./.typos.toml
+ files: doc examples include source tests
+ - name: Store typos diff file
+ run: git diff > changes-typos.diff
+ - name: archive typos results
+ uses: actions/upload-artifact@v4
+ with:
+ name: changes-typos.diff
+ path: changes-typos.diff
+ - name: Report typos as warnings
+ run: |
+ python -c '
+ import sys, json
+ old = set()
+ clean = True
+ with open(sys.argv[1]) as file:
+ for line in file:
+ new = json.loads(line)
+ if new["type"] == "typo":
+ clean = False
+ print("::warning file={},line={},col={}::perhaps \"{}\" should be \"{}\".".format(
+ new["path"], new["line_num"], new["byte_offset"],
+ new["typo"], " or ".join(new["corrections"])))
+ sys.exit(1 if not clean else 0)' "${{ runner.temp }}/typos.jsonl"
--- /dev/null
+[default]
+# Don't check text that matches the following regexes'
+extend-ignore-re = [
+ '\\cite\{.*\}', # citations contain arbitrary keys,
+ '@cite \w'
+]
+
+[default.extend-identifiers]
+# Don't correct these whole identifiers (word-groups)
+bungartz2016precice = "bungartz2016precice"
+chourdakis2021precice = "chourdakis2021precice"
+y_FoR = "y_FoR"
+use_degress = "use_degress"
+MPI_MODE_WRONLY = "MPI_MODE_WRONLY"
+Equil = "Equil"
+multline = "multline"
+
+[default.extend-words]
+# Don't correct these word (parts)
+OCE = "OCE"
+MIS = "MIS"
+parm = "parm"
+nd = "nd"
+inout = "inout"
+datas = "datas"
+Elemente = "Elemente"
+Methode = "Methode"
+workd = "workd"
+Stoer = "Stoer"
+Lik = "Lik"
+htmp = "htmp"
+Numer = "Numer"
+ue = "ue"
+reord = "reord"
+Uite = "Uite"
+strat = "strat"
+Ned = "Ned"
+BA = "BA"
+Fike = "Fike"
+clen = "clen"
+
+# Don't check the following files
+[files]
+extend-exclude = [
+ # "*.output",
+ "tests/parameter_handler/parameter_handler_25.cc", # this file contains a typo on purpose
+ "*.svg",
+ "*.pvsm",
+ "*.vtu",
+ "*.bib", # bib entries contain many arbitrary abbreviations
+ ]
<li> <p>
Improved: The class <code>Quadrature</code> has a new
constructor generating the <tt>dim</tt>-dimensional tensor product of a
- one-dimensonal formula directly.
+ one-dimensional formula directly.
<br>
(GK, 2005/06/10)
</p>
</li>
<li>
- Improved: ContraintMatrix::distribute_local_to_global now does a bulk write of
+ Improved: ConstraintMatrix::distribute_local_to_global now does a bulk write of
all vector values at once. This improves performance with
PETScWrappers::MPI::Vector by about 10%.
<br>
<li>
New: FECollection gained an equality comparison operator. Both FiniteElement
- and FECollcetion have a non-equality comparison operator now.
+ and FECollection have a non-equality comparison operator now.
<br>
(Daniel Arndt, 2018/04/25)
</li>
</li>
<li>
- New: You can now perform range-based iterations on hp::FECollecion, hp::QCollection,
+ New: You can now perform range-based iterations on hp::FECollection, hp::QCollection,
and hp::MappingCollection objects.
<br>
(Peter Munch, 2021/10/27)
--- /dev/null
+New: deal.II contributions are now automatically checked
+for typos using the 'typos' software.
+<br>
+(Rene Gassmoeller, 2024/08/12)
of files -- one file into which we write the program's member
variables, and several into which the triangulation puts its
information. We then would have to rename several files,
-preferrably as a single, "atomic" operation that cannot be
+preferably as a single, "atomic" operation that cannot be
interrupted. Implementing this is tricky and non-trivial (though
possible), and so we will not show this part and instead just
assume that nothing will happen between renaming the first
[...]
@endcode
What each of these numbers represents is hard to tell in practice, and also
-entirely unimporant for our current purposes -- it's
+entirely unimportant for our current purposes -- it's
a representation of the many objects that make up this program's state, and
from which one can restore its state. The point simply being that this is what
serialization produces: A long list (a sequence) of bits that we can put
const double t,
const double factor_solution,
const double factor_ai,
- const VectorType &corrent_ri,
+ const VectorType ¤t_ri,
VectorType &vec_ki,
VectorType &solution,
VectorType &next_ri) const;
/**
* Enum of different choices for istropic refinement.
* There are 3 different ways to refine a tetrahedral, here we save the
- * different possibilities. It is different to RefinementPossibilites are these
+ * different possibilities. It is different to RefinementPossibilities are these
* are options in the case that an isotropic refinement is conducted.
*/
enum class IsotropicRefinementChoice : std::uint8_t
// If we have the decide_and_prepare_for_remeshing callback
// set, then we also need to have the callback for actually
- // transfering the solution:
+ // transferring the solution:
AssertThrow(interpolate || transfer_solution_vectors_to_new_mesh,
StandardExceptions::ExcFunctionNotProvided(
"transfer_solution_vectors_to_new_mesh"));
PreconditionBase() = default;
/**
- * @brief Desctructor.
+ * @brief Destructor.
* Destroys the preconditioner, leaving an object like just after having
* called the constructor.
*/
*/
double min_eigenvalue;
/**
- * @brief Estimated ratio between maximum and mimimum eigenvalue.
+ * @brief Estimated ratio between maximum and minimum eigenvalue.
*
*/
double eigenvalue_ratio;
* @brief Constructor.
*
* Before factorization each diagonal entry will be modified by the
- * following fomula \f[a_{ii}^{new} = \alpha\sign(a_{ii})+\beta a_{ii}
+ * following formula \f[a_{ii}^{new} = \alpha\sign(a_{ii})+\beta a_{ii}
* \f] with \f[\alpha\f] given by ilu_atol and \f[\beta\f] given by
* ilu_rtol.
*
* @brief Constructor.
*
* Before factorization each diagonal entry will be modified by the
- * following fomula \f[a_{ii}^{new} = \alpha\sign(a_{ii})+\beta a_{ii}
+ * following formula \f[a_{ii}^{new} = \alpha\sign(a_{ii})+\beta a_{ii}
* \f] with \f[\alpha\f] given by ilut_atol and \f[\beta\f] given by
* ilut_rtol.
*
* Joscha Gedicke, U Heidelberg
*
* This file tests the non-symmetric interface to ARPACK for an
- advection-diffussion
+ advection-diffusion
* operator. The advection is chosen in such a way that we compute complex
eigenvalues.
* The most critical case when we cut a complex conjugate pair is tested, i.e.
* ------------------------------------------------------------------------
* This file tests the non-symmetric interface to PARPACK for an
- advection-diffussion
+ advection-diffusion
* operator with PETSc mpi vectors.
*
* We test that the computed vectors are eigenvectors and mass-normal, i.e.
* ------------------------------------------------------------------------
* This file tests the non-symmetric interface to PARPACK for an
- advection-diffussion
+ advection-diffusion
* operator with Trilinos mpi vectors.
*
* We test that the computed vectors are eigenvectors and mass-normal, i.e.
// Verify that DerivativeForm is trivially copyable.
// TODO not all compilers that support enough of a subset of C++11 to compile
-// the library (notably GCC 4.8) implement std::is_trivally_copyable. At some
+// the library (notably GCC 4.8) implement std::is_trivially_copyable. At some
// point in the future we should use that instead of the boost equivalent.
#include <deal.II/base/derivative_form.h>
std::vector<double> coefficients_a;
// arbitrary point
- double evalutation_number = 12.123;
+ double evaluation_number = 12.123;
for (unsigned int pp = 0; pp < p_dim; ++pp)
{
test_poly_b -= test_poly_a;
- deallog << test_poly_b.value(evalutation_number) << std::endl;
+ deallog << test_poly_b.value(evaluation_number) << std::endl;
}
}
void
test()
{
- check("wie geht es dir?", "dir", "euch", "wie geht es euch?");
+ check("how are you?", "you", "you all", "how are you all?");
check("empty from", "", "abc", "empty from");
- check("eins zwei drei", "ei", "", "ns zw dr");
- check("eins zwei drei", "zwei", "zweiundvierzig", "eins zweiundvierzig drei");
- check("wer das liest ist doof", "das liest ", "", "wer ist doof");
+ check("one two three", "e", "", "on two thr");
+ check("one two three", "two", "fortytwo", "one fortytwo three");
+ check("how are you?", "how are ", "", "you?");
check("string string", "string", "", " ");
check(" same is same", " same", " same", " same is same");
check(" ", " ", "", "");
internal::BlockVectorIterators::Iterator<BlockVector<double>,
false>>::iterator_category;
- using intervall_iterator_category =
+ using interval_iterator_category =
std::iterator_traits<IndexSet::IntervalIterator>::iterator_category;
using element_iterator_category =
std::iterator_traits<IndexSet::ElementIterator>::iterator_category;
if (level == 2)
{
Assert(boxes_in_boxes.size() == 0,
- ExcMessage("Leafs have no children."));
+ ExcMessage("Leaves have no children."));
}
else
{
AdditionalData<3> data;
data.cell_size = .1;
cgal_surface_mesh_to_cgal_triangulation(sm, tria, data);
- const unsigned int n_intial_facets = tria.number_of_facets_in_complex();
+ const unsigned int n_initial_facets = tria.number_of_facets_in_complex();
tria.clear();
data.cell_size = .5;
cgal_surface_mesh_to_cgal_triangulation(sm, tria, data);
Assert(
- n_intial_facets > tria.number_of_facets_in_complex(),
+ n_initial_facets > tria.number_of_facets_in_complex(),
ExcMessage(
"The number of facets in the finer mesh must be greater than the number of facets in the coarse mesh."));
deallog << std::boolalpha
- << (n_intial_facets > tria.number_of_facets_in_complex())
+ << (n_initial_facets > tria.number_of_facets_in_complex())
<< std::endl;
}
// ------------------------------------------------------------------------
-// this is the root cause for solution_tranfer_01: the prolongation
+// this is the root cause for solution_transfer_01: the prolongation
// matrices for FE_DGQ<dim-1,dim> were not computed at all
#include <deal.II/fe/fe_dgq.h>
std::vector<unsigned int> n_cell_smooth;
std::vector<unsigned int> n_cell_no_smooth;
- std::set<Location<dim>> final_cell_center_loactions_smooth;
- std::set<Location<dim>> final_cell_center_loactions_no_smooth;
+ std::set<Location<dim>> final_cell_center_locations_smooth;
+ std::set<Location<dim>> final_cell_center_locations_no_smooth;
if (I_am_host)
{
deallog << "Flag limit_level_difference_at_vertices set:" << std::endl;
{
TriaTest<dim> tria_test(
dealii::Triangulation<dim>::limit_level_difference_at_vertices);
- tria_test.run(n_cell_smooth, final_cell_center_loactions_smooth);
+ tria_test.run(n_cell_smooth, final_cell_center_locations_smooth);
}
if (I_am_host)
{
}
{
TriaTest<dim> tria_test(dealii::Triangulation<dim>::none);
- tria_test.run(n_cell_no_smooth, final_cell_center_loactions_no_smooth);
+ tria_test.run(n_cell_no_smooth, final_cell_center_locations_no_smooth);
}
if (I_am_host)
{
}
}
{
- bool cell_center_loactions_are_same =
- (final_cell_center_loactions_smooth.size() ==
- final_cell_center_loactions_no_smooth.size());
+ bool cell_center_locations_are_same =
+ (final_cell_center_locations_smooth.size() ==
+ final_cell_center_locations_no_smooth.size());
std::set<Location<dim>>::const_iterator it1 =
- final_cell_center_loactions_smooth.begin();
+ final_cell_center_locations_smooth.begin();
std::set<Location<dim>>::const_iterator it2 =
- final_cell_center_loactions_no_smooth.begin();
+ final_cell_center_locations_no_smooth.begin();
- for (; cell_center_loactions_are_same &&
- (it1 != final_cell_center_loactions_smooth.end());
+ for (; cell_center_locations_are_same &&
+ (it1 != final_cell_center_locations_smooth.end());
++it1, ++it2)
{
- cell_center_loactions_are_same =
- cell_center_loactions_are_same && (*it1 == *it2);
+ cell_center_locations_are_same =
+ cell_center_locations_are_same && (*it1 == *it2);
}
if (I_am_host)
{
- deallog << "cell_center_loactions_are_same = "
- << cell_center_loactions_are_same << std::endl;
+ deallog << "cell_center_locations_are_same = "
+ << cell_center_locations_are_same << std::endl;
}
}
DEAL:2d::0.875000 0.875000
DEAL:2d::Compare result:
DEAL:2d::n_cells_are_same = 1
-DEAL:2d::cell_center_loactions_are_same = 1
+DEAL:2d::cell_center_locations_are_same = 1
std::vector<unsigned int> n_cell_smooth;
std::vector<unsigned int> n_cell_no_smooth;
- std::set<Location<dim>> final_cell_center_loactions_smooth;
- std::set<Location<dim>> final_cell_center_loactions_no_smooth;
+ std::set<Location<dim>> final_cell_center_locations_smooth;
+ std::set<Location<dim>> final_cell_center_locations_no_smooth;
if (I_am_host)
{
deallog << "Flag limit_level_difference_at_vertices set:" << std::endl;
{
TriaTest<dim> tria_test(
dealii::Triangulation<dim>::limit_level_difference_at_vertices);
- tria_test.run(n_cell_smooth, final_cell_center_loactions_smooth);
+ tria_test.run(n_cell_smooth, final_cell_center_locations_smooth);
}
if (I_am_host)
{
}
{
TriaTest<dim> tria_test(dealii::Triangulation<dim>::none);
- tria_test.run(n_cell_no_smooth, final_cell_center_loactions_no_smooth);
+ tria_test.run(n_cell_no_smooth, final_cell_center_locations_no_smooth);
}
if (I_am_host)
{
}
}
{
- bool cell_center_loactions_are_same =
- (final_cell_center_loactions_smooth.size() ==
- final_cell_center_loactions_no_smooth.size());
+ bool cell_center_locations_are_same =
+ (final_cell_center_locations_smooth.size() ==
+ final_cell_center_locations_no_smooth.size());
std::set<Location<dim>>::const_iterator it1 =
- final_cell_center_loactions_smooth.begin();
+ final_cell_center_locations_smooth.begin();
std::set<Location<dim>>::const_iterator it2 =
- final_cell_center_loactions_no_smooth.begin();
+ final_cell_center_locations_no_smooth.begin();
- for (; cell_center_loactions_are_same &&
- (it1 != final_cell_center_loactions_smooth.end());
+ for (; cell_center_locations_are_same &&
+ (it1 != final_cell_center_locations_smooth.end());
++it1, ++it2)
{
- cell_center_loactions_are_same =
- cell_center_loactions_are_same && (*it1 == *it2);
+ cell_center_locations_are_same =
+ cell_center_locations_are_same && (*it1 == *it2);
}
if (I_am_host)
{
- deallog << "cell_center_loactions_are_same = "
- << cell_center_loactions_are_same << std::endl;
+ deallog << "cell_center_locations_are_same = "
+ << cell_center_locations_are_same << std::endl;
}
}
DEAL:3d::0.875000 0.875000 0.875000
DEAL:3d::Compare result:
DEAL:3d::n_cells_are_same = 1
-DEAL:3d::cell_center_loactions_are_same = 1
+DEAL:3d::cell_center_locations_are_same = 1
-// simply check what happens when condensing BlockDyanmicSparsityPattern. This
-// test was written when I changed a few things in the algorithm.
+// simply check what happens when condensing BlockDynamicSparsityPattern.
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_handler.h>
MappingQ1Eulerian<2> mapping_euler(*dof_handler_def, deformation);
// Try rotating the elements
- for (double rotat = 0; rotat < 2 * numbers::PI; rotat += 0.25 * numbers::PI)
+ for (double rotate = 0; rotate < 2 * numbers::PI;
+ rotate += 0.25 * numbers::PI)
{
// Rotate element
VectorTools::project(*dof_handler_def,
hn_constraints_def,
QGauss<2>(6),
- TestDef1<2>(2, rotat),
+ TestDef1<2>(2, rotate),
deformation);
- deallog << "phi = " << rotat << std::endl;
+ deallog << "phi = " << rotate << std::endl;
TestProjection(mapping_euler, dof_handler);
}
DoFHandler<dim> dof_handler;
AffineConstraints<double> constraints;
- Vector<double> random_fe_funtion;
+ Vector<double> random_fe_function;
const unsigned int config_switch;
constraints.close();
}
- random_fe_funtion.reinit(dof_handler.n_dofs());
+ random_fe_function.reinit(dof_handler.n_dofs());
// Fill vector with pseudo-random values
- fill_vector_randomly(random_fe_funtion, /* min */ -5.0, /* max */ 5.0);
+ fill_vector_randomly(random_fe_function, /* min */ -5.0, /* max */ 5.0);
} // make_dofs()
case FiniteElementData<dim>::Conformity::H1:
{
get_function_jump(fe_interface_values,
- random_fe_funtion,
+ random_fe_function,
interface_jumps);
deallog << "Function jumps (at quad points) in cell "
case FiniteElementData<dim>::Conformity::Hdiv:
{
get_normal_jump(fe_interface_values,
- random_fe_funtion,
+ random_fe_function,
interface_jumps);
deallog << "Normal jumps (at quad points) in cell "
case FiniteElementData<dim>::Conformity::Hcurl:
{
get_tangential_jump(fe_interface_values,
- random_fe_funtion,
+ random_fe_function,
interface_jumps);
deallog << "Tangential jumps (at quad points) in cell "
MappingQ1Eulerian<2> mapping_euler(*dof_handler_def, deformation);
// Try rotating the elements
- for (double rotat = 0; rotat < 2 * numbers::PI; rotat += 0.25 * numbers::PI)
+ for (double rotate = 0; rotate < 2 * numbers::PI;
+ rotate += 0.25 * numbers::PI)
{
// Rotate element
VectorTools::project(*dof_handler_def,
hn_constraints_def,
QGauss<2>(6),
- TestDef1<2>(2, rotat),
+ TestDef1<2>(2, rotate),
deformation);
- deallog << "phi = " << rotat << std::endl;
+ deallog << "phi = " << rotate << std::endl;
TestProjection(mapping_euler, dof_handler);
}
-// check assignment from IdenityMatrix. like the full_matrix_* tests, but use
+// check assignment from IdentityMatrix. like the full_matrix_* tests, but use
// complex-valued matrices and vectors, even though we only store real values
// in them
-// check assignment from IdenityMatrix
+// check assignment from IdentityMatrix
#include "../tests.h"
// ------------------------------------------------------------------------
// test GridTools::torus() the manifolds attached to the torus (TorusManifold,
-// ToriodalManifold, TransfiniteInterpolationManifold), output visually
+// ToroidalManifold, TransfiniteInterpolationManifold), output visually
// checked
#include <deal.II/grid/grid_generator.h>
void
setup_system();
- const unsigned int n_blocks; // total number of blocks
- const unsigned int n_components; // total number of components
- const unsigned int first_u_comp; // where displacements starts
- const unsigned int first_lamda_comp; // where lagrage multipliers start
- const unsigned int degree; // of shape functions
+ const unsigned int n_blocks; // total number of blocks
+ const unsigned int n_components; // total number of components
+ const unsigned int first_u_comp; // where displacements starts
+ const unsigned int first_lambda_comp; // where lagrage multipliers start
+ const unsigned int degree; // of shape functions
std::vector<types::global_dof_index> dofs_per_block;
// used for integral evaluation
const FEValuesExtractors::Vector u_fe;
- const FEValuesExtractors::Vector lamda_fe;
+ const FEValuesExtractors::Vector lambda_fe;
unsigned int id_of_lagrange_mult;
double beta1;
virtual void
vector_value(const Point<dim> &p, Vector<double> &values) const;
virtual double
- value(const Point<dim> &p, unsigned int compoment) const;
+ value(const Point<dim> &p, unsigned int component) const;
};
template <int dim>
template <int dim>
inline double
-BoundaryValues<dim>::value(const Point<dim> &p, unsigned int compoment) const
+BoundaryValues<dim>::value(const Point<dim> &p, unsigned int component) const
{
return -0.001;
}
: n_blocks(2)
, n_components(dim * n_blocks)
, first_u_comp(0)
- , first_lamda_comp(dim)
+ , first_lambda_comp(dim)
, degree(1)
, dofs_per_block(n_blocks)
, dof_handler(triangulation)
dim // same for lagrange multipliers
)
, u_fe(first_u_comp)
- , lamda_fe(first_lamda_comp)
+ , lambda_fe(first_lambda_comp)
, id_of_lagrange_mult(1)
, beta1(1.0)
{
<< n_elasticity_cells << std::endl;
Assert(n_lagrange_cells > 0,
ExcInternalError()); // there should be at least 1 cell! Otherwise
- // DoFHanlder crashes with 0 dofs for block 2!
+ // DoFHandler crashes with 0 dofs for block 2!
//
//(2) distribute DoFs
dof_handler.distribute_dofs(
deallog << "Total constraints: " << constraints.n_constraints()
<< std::endl
- << " Inhomogenous constraints: " << constraints.n_inhomogeneities()
+ << " Inhomogeneous constraints: " << constraints.n_inhomogeneities()
<< std::endl
<< " Identity constraints: " << constraints.n_identities()
<< std::endl;
DEAL:1d::Total constraints: 0
-DEAL:1d:: Inhomogenous constraints: 0
+DEAL:1d:: Inhomogeneous constraints: 0
DEAL:1d:: Identity constraints: 0
DEAL:2d::Total constraints: 2
-DEAL:2d:: Inhomogenous constraints: 0
+DEAL:2d:: Inhomogeneous constraints: 0
DEAL:2d:: Identity constraints: 0
DEAL:3d::Total constraints: 20
-DEAL:3d:: Inhomogenous constraints: 0
+DEAL:3d:: Inhomogeneous constraints: 0
DEAL:3d:: Identity constraints: 4
deallog << "Total constraints: " << constraints.n_constraints()
<< std::endl
- << " Inhomogenous constraints: " << constraints.n_inhomogeneities()
+ << " Inhomogeneous constraints: " << constraints.n_inhomogeneities()
<< std::endl
<< " Identity constraints: " << constraints.n_identities()
<< std::endl;
DEAL::FE degrees: 1 - 4
DEAL:2d::Total constraints: 8
-DEAL:2d:: Inhomogenous constraints: 0
+DEAL:2d:: Inhomogeneous constraints: 0
DEAL:2d:: Identity constraints: 0
DEAL:3d::Total constraints: 55
-DEAL:3d:: Inhomogenous constraints: 0
+DEAL:3d:: Inhomogeneous constraints: 0
DEAL:3d:: Identity constraints: 3
DEAL::FE degrees: 2 - 5
DEAL:2d::Total constraints: 12
-DEAL:2d:: Inhomogenous constraints: 0
+DEAL:2d:: Inhomogeneous constraints: 0
DEAL:2d:: Identity constraints: 0
DEAL:3d::Total constraints: 92
-DEAL:3d:: Inhomogenous constraints: 0
+DEAL:3d:: Inhomogeneous constraints: 0
DEAL:3d:: Identity constraints: 4
deallog << fe.get_name() << std::endl;
Triangulation<dim> tr(Triangulation<dim>::limit_level_difference_at_vertices);
- std::vector<unsigned int> repititions(dim, 1);
- repititions[0] = 2;
+ std::vector<unsigned int> repetitions(dim, 1);
+ repetitions[0] = 2;
const Point<dim> p1 =
(dim == 1 ? Point<dim>(-1.) :
(dim == 2 ? Point<dim>(-1., -1.) : Point<dim>(-1., -1., -1.)));
const Point<dim> p2 =
(dim == 1 ? Point<dim>(1.) :
(dim == 2 ? Point<dim>(1., 1.) : Point<dim>(1., 1., 1.)));
- GridGenerator::subdivided_hyper_rectangle(tr, repititions, p1, p2);
+ GridGenerator::subdivided_hyper_rectangle(tr, repetitions, p1, p2);
tr.begin_active()->set_refine_flag();
tr.execute_coarsening_and_refinement();
// of applying the constraints directly to the solution obtained by solving
// the system:
// (C^T * A * C + Id_c) * x = C^t * (b - A * k)
-// with the help of constrainted_linear_operator and
+// with the help of constrained_linear_operator and
// constrained_right_hand_side
#include <deal.II/base/quadrature_lib.h>
-// this tests the correctness of distribute_local_to_globa() for DiagonalMatrix
+// this tests the correctness of distribute_local_to_global() for DiagonalMatrix
#include <deal.II/base/function.h>
#include <deal.II/base/utilities.h>
// ------------------------------------------------------------------------
-// Checks if vertices on face are given in correct oder
+// Checks if vertices on face are given in correct order
#include <deal.II/fe/mapping_q.h>
{}
double
- value(const Point<dim> &point, const unsigned int compontent) const
+ value(const Point<dim> &point, const unsigned int component) const
{
- return std::sin(point[compontent] * 0.5 * numbers::PI) -
- (is_displacement_function ? point[compontent] : 0.0);
+ return std::sin(point[component] * 0.5 * numbers::PI) -
+ (is_displacement_function ? point[component] : 0.0);
}
private:
const Point<2> &p) -> Point<2> {
Point<2> result;
- for (unsigned int compontent = 0; compontent < 2; ++compontent)
- result[compontent] =
- std::sin(p[compontent] * 0.5 * numbers::PI) - p[compontent];
+ for (unsigned int component = 0; component < 2; ++component)
+ result[component] =
+ std::sin(p[component] * 0.5 * numbers::PI) - p[component];
return result;
},
const Point<2> &p) -> Point<2> {
Point<2> result;
- for (unsigned int compontent = 0; compontent < 2; ++compontent)
- result[compontent] = std::sin(p[compontent] * 0.5 * numbers::PI);
+ for (unsigned int component = 0; component < 2; ++component)
+ result[component] = std::sin(p[component] * 0.5 * numbers::PI);
return result;
},
{}
double
- value(const Point<dim> &point, const unsigned int compontent) const
+ value(const Point<dim> &point, const unsigned int component) const
{
- return std::sin(point[compontent] * 0.5 * numbers::PI) -
- (is_displacement_function ? point[compontent] : 0.0);
+ return std::sin(point[component] * 0.5 * numbers::PI) -
+ (is_displacement_function ? point[component] : 0.0);
}
private:
if (vector_describes_relative_displacement)
{
- Vector<double> absolut_vector(dof_handler_dim.n_dofs());
- VectorTools::get_position_vector(dof_handler_dim, absolut_vector);
+ Vector<double> absolute_vector(dof_handler_dim.n_dofs());
+ VectorTools::get_position_vector(dof_handler_dim, absolute_vector);
- euler_vector -= absolut_vector;
+ euler_vector -= absolute_vector;
}
// output mesh with with MappingFEField based on a vector constructed
Triangulation<dim> tria;
GridGenerator::reference_cell(tria, fe.reference_cell());
- FE_SimplexP<dim> fe_continous(fe.degree);
+ FE_SimplexP<dim> fe_continuous(fe.degree);
DoFHandler<dim> dof_handler(tria);
- dof_handler.distribute_dofs(fe_continous);
+ dof_handler.distribute_dofs(fe_continuous);
std::vector<types::global_dof_index> dof_indices(
- fe_continous.n_dofs_per_face());
+ fe_continuous.n_dofs_per_face());
for (const auto &cell : dof_handler.active_cell_iterators())
{
unsigned int face_counter = 0;
//
// ------------------------------------------------------------------------
-// Check if intialization of FEFaceEvaluation works for hp + DG in 3D.
+// Check if initialization of FEFaceEvaluation works for hp + DG in 3D.
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/mapping_q1.h>
// This function tests the correctness of the matrix-free implementation
// of the FE_RaviartThomasNodal element by evaluating values + gradients
-// as well as the divergence and comparing the result with FEVaules which
+// as well as the divergence and comparing the result with FEValues which
// is considered the reference. The mesh is a hypercube mesh with no
// hanging nodes and no other constraints.
// This function tests the correctness of the matrix-free implementation
// of the FE_RaviartThomasNodal element by evaluating values + gradients
// as well as the divergence on faces and comparing the result with
-// FEFaceVaules which is considered the reference. The mesh is a hypercube
+// FEFaceValues which is considered the reference. The mesh is a hypercube
// mesh with no hanging nodes and no other constraints.
#include "../tests.h"
-// document bug in the DerivateApproximation in parallel
+// document bug in the DerivativeApproximation in parallel
/*
--------------------------------------------------------
An error occurred in line <3349> of file
GridGenerator::subdivided_hyper_cube(basetria, 4);
basetria.refine_global(4);
- const auto deterimine_n_coarse_cells = [&comm](auto &tria) {
+ const auto determine_n_coarse_cells = [&comm](auto &tria) {
types::coarse_cell_id n_coarse_cells = 0;
for (auto cell : tria.active_cell_iterators())
// create translator: CellID <-> unique ID
internal::CellIDTranslator<dim> cell_id_translator(
- deterimine_n_coarse_cells(basetria), basetria.n_global_levels());
+ determine_n_coarse_cells(basetria), basetria.n_global_levels());
for (auto cell : basetria.cell_iterators())
-template <int dim, typename number, int spacedim>
-void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> &v)
-{
- for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
- {
- unsigned int n = mg_dof.n_dofs(level);
- v[level].reinit(n);
- }
-}
-
-
template <typename Transfer>
void
make_matrix(const Transfer &transfer,
-template <int dim, typename number, int spacedim>
-void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> &v)
-{
- for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
- {
- unsigned int n = mg_dof.n_dofs(level);
- v[level].reinit(n);
- }
-}
-
-
template <typename Transfer>
void
make_matrix(const Transfer &transfer,
-template <int dim, typename number, int spacedim>
-void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> &v)
-{
- for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
- {
- unsigned int n = mg_dof.n_dofs(level);
- v[level].reinit(n);
- }
-}
-
-
template <typename Transfer>
void
make_matrix(const Transfer &transfer,
-template <int dim, typename number, int spacedim>
-void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> &v)
-{
- for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
- {
- unsigned int n = mg_dof.n_dofs(level);
- v[level].reinit(n);
- }
-}
-
-
template <typename Transfer>
void
make_matrix(const Transfer &transfer,
-template <int dim, typename number, int spacedim>
-void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> &v)
-{
- for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
- {
- unsigned int n = mg_dof.n_dofs(level);
- v[level].reinit(n);
- }
-}
-
-
template <typename Transfer>
void
make_matrix(const Transfer &transfer,
-template <int dim, typename number, int spacedim>
-void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> &v)
-{
- for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
- {
- unsigned int n = mg_dof.n_dofs(level);
- v[level].reinit(n);
- }
-}
-
-
template <typename Transfer>
void
make_matrix(const Transfer &transfer,
-template <int dim, typename number, int spacedim>
-void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> &v)
-{
- for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
- {
- unsigned int n = mg_dof.n_dofs(level);
- v[level].reinit(n);
- }
-}
-
-
template <typename Transfer>
void
make_matrix(const Transfer &transfer,
-template <int dim, typename number, int spacedim>
-void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> &v)
-{
- for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
- {
- unsigned int n = mg_dof.n_dofs(level);
- v[level].reinit(n);
- }
-}
-
-
template <typename Transfer>
void
make_matrix(const Transfer &transfer,
-template <int dim, typename number, int spacedim>
-void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> &v)
-{
- for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
- {
- unsigned int n = mg_dof.n_dofs(level);
- v[level].reinit(n);
- }
-}
-
-
template <typename Transfer>
void
make_matrix(const Transfer &transfer,
-template <int dim, typename number, int spacedim>
-void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> &v)
-{
- for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
- {
- unsigned int n = mg_dof.n_dofs(level);
- v[level].reinit(n);
- }
-}
-
-
template <typename Transfer>
void
make_matrix(const Transfer &transfer,
-template <int dim, typename number, int spacedim>
-void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> &v)
-{
- for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
- {
- unsigned int n = mg_dof.n_dofs(level);
- v[level].reinit(n);
- }
-}
-
-
template <typename Transfer>
void
make_matrix(const Transfer &transfer,
-template <int dim, typename number, int spacedim>
-void
-reinit_vector(const dealii::DoFHandler<dim, spacedim> &mg_dof,
- MGLevelObject<dealii::Vector<number>> &v)
-{
- for (unsigned int level = v.min_level(); level <= v.max_leve(); ++level)
- {
- unsigned int n = mg_dof.n_dofs(level);
- v[level].reinit(n);
- }
-}
-
-
template <typename Transfer>
void
make_matrix(const Transfer &transfer,
// functions are negative between the support points.
template <int dim>
void
-test_lagrange_coefficents_positive()
+test_lagrange_coefficients_positive()
{
- deallog << "test_lagrange_coefficents_positive" << std::endl;
+ deallog << "test_lagrange_coefficients_positive" << std::endl;
Triangulation<dim> triangulation;
GridGenerator::hyper_cube(triangulation);
test_intersection_x_eq_0_plane<dim>();
// This test doesn't make sense in 1D.
if (dim != 1)
- test_lagrange_coefficents_positive<dim>();
+ test_lagrange_coefficients_positive<dim>();
test_reclassify_called_multiple_times<dim>();
}
DEAL::face 2 intersected
DEAL::face 3 intersected
DEAL::
-DEAL::test_lagrange_coefficents_positive
+DEAL::test_lagrange_coefficients_positive
DEAL::cell intersected
DEAL::face 0 outside
DEAL::face 1 outside
DEAL::face 4 intersected
DEAL::face 5 intersected
DEAL::
-DEAL::test_lagrange_coefficents_positive
+DEAL::test_lagrange_coefficients_positive
DEAL::cell intersected
DEAL::face 0 outside
DEAL::face 1 intersected
{
"General": {
- "Precison": "float"
+ "Precision": "float"
}
}
subsection General
- set Precison = float
+ set Precision = float
end
std::vector<typename Particles::PropertyPool<dim, spacedim>::Handle>
particle_handles;
- // Allocate some space in non-contigous locations
+ // Allocate some space in non-contiguous locations
particle_handles.push_back(pool.register_particle());
particle_handles.insert(particle_handles.begin(), pool.register_particle());
particle_handles.push_back(pool.register_particle());
* infrastructure on the CPU. Considered are the initialization
* costs and the costs for an operator evaluation.
* CUDAWrapper::MatrixFree was written with CUDA and now uses
- * Kokkos as backend and, as consequnce, favors GPU hardware. This
+ * Kokkos as backend and, as consequence, favors GPU hardware. This
* performance test is meant to track the improvement of
* the performance of CUDAWrapper::MatrixFree on the CPU.
*
// The following function is similar to that in step-77,
// except that it supports parallel assembly.
- // The Jacobian is assembled using homogenous boundary conditions
+ // The Jacobian is assembled using homogeneous boundary conditions
// since we always solve for the update step.
// Here we don't need to reevaluate the `locally_relevant_solution`
// vector since SNES guaranties that the Jacobian callback is called
// Again, this is basically a verbatim copy of the function in step-77.
// The only differences are in how we setup the nonlinear solver and in
- // the way we handle non-homogenous boundary conditions.
+ // the way we handle non-homogeneous boundary conditions.
template <int dim>
void
MinimalSurfaceProblem<dim>::run()
// We are now set up to solve the nonlinear system
nonlinear_solver.solve(current_solution);
- // Differently from step-77, we apply non-homogenous boundary
+ // Differently from step-77, we apply non-homogeneous boundary
// conditions only once, after the algebraic solve is done.
// Note that this call is only needed since this example uses hanging
// nodes constraints.
#include "../tests.h"
// These tests were used while building extensions for
-// PetscSclar=complex. They check that std::complex<double> and
+// PetscScalar=complex. They check that std::complex<double> and
// PetscScalar complex are compatible without explicitly casting.
//
// These tests look archaic - they are the original tests used to
MappingQ1<patch_dim, spacedim> mapping_slice;
- parallel::distributed::Triangulation<dim, spacedim> tria_backround(comm);
- GridGenerator::hyper_cube(tria_backround, -1.0, +1.0);
- tria_backround.refine_global(n_refinements_1);
+ parallel::distributed::Triangulation<dim, spacedim> tria_background(comm);
+ GridGenerator::hyper_cube(tria_background, -1.0, +1.0);
+ tria_background.refine_global(n_refinements_1);
- DoFHandler<dim, spacedim> dof_handler(tria_backround);
+ DoFHandler<dim, spacedim> dof_handler(tria_background);
dof_handler.distribute_dofs(FE_Q<dim, spacedim>{1});
MappingQ1<dim, spacedim> mapping;
MappingQ1<patch_dim, spacedim> mapping_slice;
- parallel::distributed::Triangulation<dim, spacedim> tria_backround(comm);
- GridGenerator::hyper_cube(tria_backround, -1.0, +1.0);
- tria_backround.refine_global(n_refinements_1);
+ parallel::distributed::Triangulation<dim, spacedim> tria_background(comm);
+ GridGenerator::hyper_cube(tria_background, -1.0, +1.0);
+ tria_background.refine_global(n_refinements_1);
- DoFHandler<dim, spacedim> dof_handler(tria_backround);
+ DoFHandler<dim, spacedim> dof_handler(tria_background);
dof_handler.distribute_dofs(
FESystem<dim, spacedim>(FE_Q<dim, spacedim>{1}, n_components));
{}
double
- value(const Point<dim> &point, const unsigned int compontent) const
+ value(const Point<dim> &point, const unsigned int component) const
{
- return std::sin(point[compontent] * 0.5 * numbers::PI);
+ return std::sin(point[component] * 0.5 * numbers::PI);
}
};
create_triangulation(const std::vector<Point<3>> &vertices_,
const std::vector<CellData<3>> &cell_data_,
const unsigned int face_n,
- const unsigned int n_permuations,
+ const unsigned int n_permutations,
Triangulation<3> &tria)
{
const ReferenceCell ref_cell = ReferenceCells::Tetrahedron;
tria.create_triangulation(vertices, cell_data, SubCellData());
++permutation_n;
}
- while ((permutation_n < n_permuations) &&
+ while ((permutation_n < n_permutations) &&
std::next_permutation(cell_data.back().vertices.begin(),
cell_data.back().vertices.end()));
constexpr Tensor<1, 3> dummy_1;
constexpr Tensor<0, 3> dummy_0;
DEAL_II_CONSTEXPR auto product_result = dummy_1 * dummy_1;
- DEAL_II_CONSTEXPR auto constraction_result =
+ DEAL_II_CONSTEXPR auto contraction_result =
contract<0, 0>(dummy_1, dummy_1);
DEAL_II_CONSTEXPR auto outer_product_result =
outer_product(dummy_0, dummy_0);
// Verify that SymmetricTensor is trivially copyable.
// TODO not all compilers that support enough of a subset of C++11 to compile
-// the library (notably GCC 4.8) implement std::is_trivally_copyable. At some
+// the library (notably GCC 4.8) implement std::is_trivially_copyable. At some
// point in the future we should use that instead of the boost equivalent.
#include <deal.II/base/symmetric_tensor.h>
// Verify that Tensor is trivially copyable.
// TODO not all compilers that support enough of a subset of C++11 to compile
-// the library (notably GCC 4.8) implement std::is_trivally_copyable. At some
+// the library (notably GCC 4.8) implement std::is_trivially_copyable. At some
// point in the future we should use that instead of the boost equivalent.
#include <deal.II/base/tensor.h>
projects / dealii.git / commitdiff