print_time(time);
time.advance_time(); // Here we reach the end time.
print_time(time);
- // If we call time.advance_time() one more time, it fails an assersion
+ // If we call time.advance_time() one more time, it fails an assertion
deallog << "OK" << std::endl;
}
Functions::InterpolatedTensorProductGridData<dim> f(std::move(coordinates),
std::move(data));
- // Verify tha the data has really been moved
+ // Verify that the data has really been moved
for (unsigned int d = 0; d < dim; ++d)
Assert(data.size()[d] == 0, ExcInternalError());
for (unsigned int d = 0; d < dim; ++d)
std::move(n_subintervals),
std::move(data));
- // Verify tha the data has really been moved
+ // Verify that the data has really been moved
for (unsigned int d = 0; d < dim; ++d)
Assert(data.size()[d] == 0, ExcInternalError());
0, // fourth point
0,
0,
- 3}; // fith point
+ 3}; // fifth point
std::vector<Number> data = {32, 33, 35, 36, 38};
dataset.write_selection(data, coordinates);
0, // fourth point
0,
0,
- 3}; // fith point
+ 3}; // fifth point
Vector<Number> data(5);
data[0] = 32;
data[1] = 33;
1, // fourth point
0,
3,
- 2}; // fith point
+ 2}; // fifth point
auto data = dataset.read_selection<std::vector<Number>>(coordinates);
1, // fourth point
0,
3,
- 2}; // fith point
+ 2}; // fifth point
auto data = dataset.read_selection<Vector<Number>>(coordinates);
0, // fourth point
0,
0,
- 3}; // fith point
+ 3}; // fifth point
std::vector<Number> data = {32, 33, 35, 36, 38};
dataset.write_selection(data, coordinates);
0, // fourth point
0,
0,
- 3}; // fith point
+ 3}; // fifth point
Vector<Number> data(5);
data[0] = 32;
data[1] = 33;
1, // fourth point
0,
3,
- 2}; // fith point
+ 2}; // fifth point
auto data = dataset.read_selection<std::vector<Number>>(coordinates);
1, // fourth point
0,
3,
- 2}; // fith point
+ 2}; // fifth point
auto data = dataset.read_selection<Vector<Number>>(coordinates);
//
// ---------------------------------------------------------------------
-// Test conversion from CGAL to deal.II Point and viceversa
+// Test conversion from CGAL to deal.II Point and vice-versa
#include <deal.II/base/point.h>
// ---------------------------------------------------------------------
// Convert a deal.II triangulation to a CGAL surface mesh. In the 2D case,
-// thw whole triangulation is a 2D surface mesh. In 3D, the surface mesh
+// the whole triangulation is a 2D surface mesh. In 3D, the surface mesh
// describes the boundary of the deal.II Triangulation.
#include <deal.II/base/config.h>
// Create a Surface_mesh from each cell of an hyper ball, to check for
// orientation issues that may arise in Hexaedrons with non-standard face
-// orientations. Make sure this works also when tranforming the grid to a
-// simplex one.
+// orientations. Make sure this works also when transforming the grid to
+// a simplex one.
#include <deal.II/base/config.h>
{
triangulation.clear();
- // alias for better readabilty
+ // alias for better readability
const unsigned int n_rotate_central_square = config_switch;
GridGenerator::non_standard_orientation_mesh(triangulation,
/*
* EstimateEnrichmentFunction is used to estimate enrichment function by
- * solveing a 1D poisson problem with right hand side and boundary
+ * solving a 1D poisson problem with right hand side and boundary
* expression provided as a string of single variable 'x', to be
* interpreted as distance from @par center.
*
if (prm.debug_level >= 2 && this_mpi_process == 0)
output_results(cycle);
- // Donot refine if loop is at the end
+ // Do not refine if loop is at the end
if (cycle != prm.cycles)
refine_grid();
VectorTools::project_boundary_values_curl_conforming_l2(
dof_handler,
- 0, // starting compenent
+ 0, // starting component
BoundaryValues<dim>(),
1, // face ID1
constraints,
VectorTools::project_boundary_values_curl_conforming_l2(
dof_handler,
- 0, // starting compenent
+ 0, // starting component
BoundaryValues<dim>(),
1, // face ID1
constraints,
StaticMappingQ1<dim>::mapping);
VectorTools::project_boundary_values_curl_conforming_l2(
dof_handler,
- dim, // starting compenent
+ dim, // starting component
BoundaryValues<dim>(),
1, // face ID1
constraints,
// The test is used to check the restriction_is_additive flags. The
// face degrees of freedom of an RT_Bubbles element must be non-additive
-// as they have continuity requrements. The interior DoFs however must
+// as they have continuity requirements. The interior DoFs however must
// be additive.
#include <deal.II/fe/fe_rt_bubbles.h>
GridTools::get_cells_at_coarsest_common_level<Triangulation<dim>>(
patch_cells);
- // in uniform refinemenet(without any hanging nodes), we expect the size
+ // in uniform refinement(without any hanging nodes), we expect the size
// of vector of patch_cells for each cell be equal to the vector of
// coarse_cells around that cell
Assert(patch_cells.size() == coarse_cells.size(), ExcInternalError());
cell->set_refine_flag();
// make sure that the
- // corrsponding cell
+ // corresponding cell
// on grid 2 is also
// refined if that
// has not yet
-// implementatoin
+// implementation
template <int dim>
Laplace<dim>::Laplace(const Function<dim> &force_function,
const Function<dim> &exact_solution,
PRINTME("Tvmult_add", x);
- // Test vector reinitalization:
+ // Test vector reinitialization:
op_x = op_b * op_b * op_b;
op_x.vmult(x, u);
PRINTME("(A-B).Tvmult_add", x);
- // Test vector reinitalization:
+ // Test vector reinitialization:
op_x = op_b * op_b * op_b;
op_x.vmult(x, u);
#include "../tests.h"
/*
- * Test ImplicitQR::append_column() with lineary dependent columns.
+ * Test ImplicitQR::append_column() with linearly dependent columns.
* The output should be the same as qr_03 test plus extra output due to
* the rejected column.
*/
/*
- * MWE in Python for standard QR with 3 linearly independet columns. We will add
+ * MWE in Python for standard QR with 3 linearly independent columns. We will add
the fourth one:
import numpy as np
-// Test to verify correctness of SolverFIRE::sovle()
+// Test to verify correctness of SolverFIRE::solve()
// The objective function is the extended Rosenbrock function.
// The Rosenbrock function is a non-convex function used as a test problem
// for optimization algorithms introduced by Howard H. Rosenbrock.
- // Generate an hyper_shell over an EllipticalManifold having an abitrary
+ // Generate an hyper_shell over an EllipticalManifold having an arbitrary
// center, and the major axis oriented in the direction of the x-axis.
//
// inner_radius and outer_radius parameters correspond to the
* -0.1271 -0.0177875 -> 0.253794 -0.0323121
* -0.1271 -0.015564 -> 0.251301 -0.0309146
*
- * The following is a simplified version that fails with a sligthly
+ * The following is a simplified version that fails with a slightly
* different error message.
*/
-// Similar to compute_diagonal_02 but testing block vectorss.
+// Similar to compute_diagonal_02 but testing block vectors.
#include <deal.II/lac/la_parallel_block_vector.h>
// experiencing was the mesh I was testing on was too coarse for
// larger number of processors. This test case shows that as
// well. For 4 processors the code produces output without error
-// for both the 12 repitions and the 2 repititions. For 6 and 12
+// for both the 12 repitions and the 2 repetitions. For 6 and 12
// processors only the 12 repetition case produces the proper
// output. Fortunately it does show as long as the mesh is
// adequately refined DataOutFaces produces the output for each
cell->set_refine_flag();
tria.execute_coarsening_and_refinement();
- // setup finite elemets
+ // setup finite elements
hp::FECollection<dim> fes;
fes.push_back(FE_Q<dim>(1));
// check that the AffineConstraints<double> with hanging nodes and
// no-normal-flux constraints on an adaptively refined hyper_cube are the same
-// independet of the number of CPUs
+// independent of the number of CPUs
#include <deal.II/base/tensor.h>
/*
- * We craete a distrubuted mesh with three cells (tree roots), e.g., a
+ * We create a distributed mesh with three cells (tree roots), e.g., a
* hyper_L. We want to find the mpi rank of a single fixed point. On all
* processes we must find the same owner.
*/
/*
- * We craete a distrubuted mesh with three cells (tree roots), e.g., a
+ * We create a distributed mesh with three cells (tree roots), e.g., a
* hyper_L. We want to find the mpi rank of a set of fixed points. On all
* processes we must find the same owner ranks.
*/
/*
- * We craete a distrubuted mesh with three cells (tree roots), e.g., a
+ * We create a distributed mesh with three cells (tree roots), e.g., a
* hyper_L. We want to find the mpi rank of a single fixed point. On all
* processes we must find the same owner.
*/
/*
- * We craete a distrubuted mesh with three cells (tree roots), e.g., a
+ * We create a distributed mesh with three cells (tree roots), e.g., a
* hyper_L. We want to find the mpi rank of a set of fixed points. On all
* processes we must find the same owner ranks.
*/
for (int d = 0; d < dim; ++d)
center(d) = .5;
- // For each coordinate direction set up a plane throught the center.
+ // For each coordinate direction set up a plane through the center.
for (int plane_direction = 0; plane_direction < dim; ++plane_direction)
{
const Tensor<1, dim> normal = Point<dim>::unit_vector(plane_direction);
// ---------------------------------------------------------------------
// Test VectorTools::project_boundary_values_div_conforming for the
-// case that the DoFHandler constains is more than one FE_RaviartThomas element.
+// case that the DoFHandler contains is more than one FE_RaviartThomas element.
#include <deal.II/base/function.h>
// ---------------------------------------------------------------------
// Test VectorTools::project_boundary_values_div_conforming convergence rates
-// for the case that the DoFHandler constains more than one
+// for the case that the DoFHandler contains more than one
// FE_RaviartThomas element.
#include <deal.II/base/function.h>
{
deallog << "Case 3:" << std::endl;
// Now do a big step so that next one in bracketing satisfies both Wolf:
- // at the termination point the derivative is alos negative!
+ // at the termination point the derivative is also negative!
// Also that point satisfies both Wolfe conditions as well, but
// we are interested in another segment, which contains local
// minimizer
ParticleTracking<dim>::generate_particles()
{
// We create an hyper ball triangulation which we globally refine. The bug
- // that this test tries to reproduce only occured in curevd geometry.
+ // that this test tries to reproduce only occurred in curved geometry.
Point<dim> center_of_triangulation;
center_of_triangulation[0] = 0.;
center_of_triangulation[1] = 0.;
//
// ---------------------------------------------------------------------
-// Adoptation of base/utilities_pack_unpack_01.cc as a quick test.
+// Adaptation of base/utilities_pack_unpack_01.cc as a quick test.
// test Utilities::pack/unpack on some types.
const unsigned int n_refinements_1 = 2;
const unsigned int n_refinements_2 = 3;
- // backgroud mesh
+ // background mesh
parallel::distributed::Triangulation<dim> tria_1(MPI_COMM_WORLD);
GridGenerator::hyper_cube(tria_1, -1.0, +1.0);
tria_1.refine_global(n_refinements_1);
deallog << "Files " << output_basename + ".h5"
<< " and " << output_basename + ".xdmf"
- << " created succesfully!" << std::endl;
+ << " created successfully!" << std::endl;
}
int
-DEAL::Files test.2.0.h5 and test.2.0.xdmf created succesfully!
-DEAL::Files test.2.1.h5 and test.2.1.xdmf created succesfully!
-DEAL::Files test.2.2.h5 and test.2.2.xdmf created succesfully!
-DEAL::Files test.3.0.h5 and test.3.0.xdmf created succesfully!
-DEAL::Files test.3.1.h5 and test.3.1.xdmf created succesfully!
-DEAL::Files test.3.2.h5 and test.3.2.xdmf created succesfully!
\ No newline at end of file
+DEAL::Files test.2.0.h5 and test.2.0.xdmf created successfully!
+DEAL::Files test.2.1.h5 and test.2.1.xdmf created successfully!
+DEAL::Files test.2.2.h5 and test.2.2.xdmf created successfully!
+DEAL::Files test.3.0.h5 and test.3.0.xdmf created successfully!
+DEAL::Files test.3.1.h5 and test.3.1.xdmf created successfully!
+DEAL::Files test.3.2.h5 and test.3.2.xdmf created successfully!
\ No newline at end of file
deallog << "Files " << output_basename + ".h5"
<< " and " << output_basename + ".xdmf"
- << " created succesfully!" << std::endl;
+ << " created successfully!" << std::endl;
}
}
-DEAL::Files test.2.0.h5 and test.2.0.xdmf created succesfully!
-DEAL::Files test.2.1.h5 and test.2.1.xdmf created succesfully!
-DEAL::Files test.2.2.h5 and test.2.2.xdmf created succesfully!
-DEAL::Files test.3.0.h5 and test.3.0.xdmf created succesfully!
-DEAL::Files test.3.1.h5 and test.3.1.xdmf created succesfully!
-DEAL::Files test.3.2.h5 and test.3.2.xdmf created succesfully!
\ No newline at end of file
+DEAL::Files test.2.0.h5 and test.2.0.xdmf created successfully!
+DEAL::Files test.2.1.h5 and test.2.1.xdmf created successfully!
+DEAL::Files test.2.2.h5 and test.2.2.xdmf created successfully!
+DEAL::Files test.3.0.h5 and test.3.0.xdmf created successfully!
+DEAL::Files test.3.1.h5 and test.3.1.xdmf created successfully!
+DEAL::Files test.3.2.h5 and test.3.2.xdmf created successfully!
\ No newline at end of file
-// miscellaneous helper funcions for hanging_nodes_* tests
+// miscellaneous helper functions for hanging_nodes_* tests
#include <deal.II/dofs/dof_handler.h>
unrefined_f = f;
// verify whether unrefined cell and neighboring children have matching
- // vertices on their correpsonding subface
+ // vertices on their corresponding subface
for (unsigned int sf = 0; sf < GeometryInfo<dim>::max_children_per_face; ++sf)
{
// unrefined vertex on subface
// check DynamicSparsityPattern::compute_Tmmult_pattern(). Test if
// multiplication with each combination of SparsityPatternTypes is possible.
-// This is an adoptation of the dynamic_sparsity_pattern_compute_mmult_1.cc
+// This is an adaptation of the dynamic_sparsity_pattern_compute_mmult_1.cc
#include <deal.II/lac/dynamic_sparsity_pattern.h>
#include <deal.II/lac/sparsity_pattern.h>
// check DynamicSparsityPattern::compute_Tmmult_pattern(). Test if
// multiplication of two patterns yield the right DynamicSparsityPattern. This
-// is an adoptation of the dynamic_sparsity_pattern_compute_mmult_2.cc
+// is an adaptation of the dynamic_sparsity_pattern_compute_mmult_2.cc
#include <deal.II/lac/dynamic_sparsity_pattern.h>
#include <deal.II/lac/full_matrix.h>
}
/**
- * Create a vector for testing and intialize all entries to @p value.
+ * Create a vector for testing and initialize all entries to @p value.
*/
template <typename VectorType>
VectorType
// 0. Define some independent variables
// Here we have two definitions of Q: One it is treated as a completely
- // indepdent variable, and the other where its dependence on C is
+ // independent variable, and the other where its dependence on C is
// explicitly defined
SE::RCP<const SE::Symbol> C = SE::symbol("C"); // Primary variable
SE::RCP<const SE::Symbol> Qi = SE::symbol("Qi"); // Some internal variable
// Optimizer
SD::BatchOptimizer<NumberType> optimizer;
- // Deserialze
+ // Deserialize
deallog << "Deserializing..." << std::endl;
std::istringstream iss(oss.str());
boost::archive::text_iarchive ia(iss, boost::archive::no_header);
// Optimizer
SD::BatchOptimizer<NumberType> optimizer;
- // Deserialze
+ // Deserialize
std::cout << "Deserializing..." << std::endl;
std::istringstream iss(oss.str());
boost::archive::text_iarchive ia(iss, boost::archive::no_header);
f *= x; // f = x^2
const SD_number_t df_dx = f.differentiate(x);
Assert(static_cast<bool>(df_dx == (2.0 * x)),
- ExcMessage("Problem with differentiaton"));
+ ExcMessage("Problem with differentiation"));
}
std::cout << "Basic differentiation (Symbol)" << std::endl;
f *= x; // f = x^2
const SD_number_t df_dx = f.differentiate(symb_x);
Assert(static_cast<bool>(df_dx == SD_number_t(2.0 * x)),
- ExcMessage("Problem with differentiaton"));
+ ExcMessage("Problem with differentiation"));
}
std::cout << "Basic differentiation (Basic representing a symbolic type)"
// 2.0 * SD_number_t(symb_x_plus_y) = 2.0*(x + y)
// Assert(static_cast<bool>(df_dxpy == (2.0 *
// SD_number_t(symb_x_plus_y))),
- // ExcMessage("Problem with differentiaton"));
+ // ExcMessage("Problem with differentiation"));
}
}
* If we run 64 tests at the same time on a 64-core system, and each of
* them runs 64 threads, then we get astronomical loads. Limit concurrency
* to a fixed (small) number of threads, independent of the core count. The
- * limit defaults to 3 and can be overriden by the environment variable
+ * limit defaults to 3 and can be overridden by the environment variable
* TEST_N_THREADS.
*/
inline unsigned int
projects / dealii.git / commitdiff