and a classical displacement based method is recovered.
For fully-incompressible materials $\nu = 0.5$ and the three-field formulation will still exhibit
-locking behaviour.
+locking behavior.
This can be overcome by introducing an additional constraint into the free energy of the form
$\int_{\Omega_0} \Lambda [ \widetilde{J} - 1]~\textrm{d}V$.
Here $\Lambda$ is a Lagrange multiplier to enforce the isochoric constraint.
// As discussed in the Introduction, Neo-Hookean materials are a type of
// hyperelastic materials. The entire domain is assumed to be composed of a
- // compressible neo-Hookean material. This class defines the behaviour of
+ // compressible neo-Hookean material. This class defines the behavior of
// this material within a three-field formulation. Compressible neo-Hookean
// materials can be described by a strain-energy function (SEF) $ \Psi =
// \Psi_{\text{iso}}(\overline{\mathbf{b}}) + \Psi_{\text{vol}}(\widetilde{J})
* @endcode
* Note that there is only one section "Forcing term", this is because
* both objects have defined the same name for the section of their
- * SomeParsedClass. There are two strategies to change this behaviour. The
+ * SomeParsedClass. There are two strategies to change this behavior. The
* first one (not recommended) would be to change the name of the section
* of SomeParsedClass such that it contains also the string passed to
* the constructor of MyClass:
*
* If you call update_user_substitution_map() and
* set_additional_function_arguments() with the same argument, the effect on
- * the function evaluation will be the same, however, the internal behaviour
+ * the function evaluation will be the same, however, the internal behavior
* and function derivatives will be different. The method
* update_user_substitution_map() performs the substitution once (the first
* time it is required), and then stores internally a copy of the resulting
* the <tt>Function</tt> class, one can ask for a specific component only, or
* use the <tt>vector_value</tt> function, which however does not return the
* value, but rather writes it into the address provided by its second
- * argument. The reason for the different behaviour of the classes is that in
+ * argument. The reason for the different behavior of the classes is that in
* the case of tensor valued functions, the size of the argument is known to
* the compiler a priori, such that the correct amount of memory can be
* allocated on the stack for the return value; on the other hand, for the
* every time a repartitioning in p4est happens. This can be a bit more
* expensive, but guarantees the same memory layout and therefore cell
* ordering in the deal.II mesh. As assembly is done in the deal.II
- * cell ordering, this flag is required to get reproducible behaviour
+ * cell ordering, this flag is required to get reproducible behavior
* after snapshot/resume.
*/
mesh_reconstruction_after_repartitioning = 0x1,
* <h3>Initialization of filtered iterators</h3>
*
* Filtered iterators are given a predicate at construction time which cannot
- * be changed any more. This behaviour would be expected if the predicate
+ * be changed any more. This behavior would be expected if the predicate
* would have been given as a template parameter to the class, but since that
* would make the declaration of filtered iterators a nightmare, we rather
* give the predicate as an unchangeable entity to the constructor. Note that
* GridTools::regularize_corner_cells(tria);
* tria.refine_global(2);
* @endcode
- * generates a mesh that has a much better behaviour w.r.t. the jacobian of
+ * generates a mesh that has a much better behavior w.r.t. the jacobian of
* the Mapping:
*
* <p ALIGN="center">
* method does return true, this does not imply that the hp method will
* work!
*
- * This behaviour is related to the fact, that FiniteElement classes,
+ * This behavior is related to the fact, that FiniteElement classes,
* which provide the new style hanging node constraints might still not
* provide them for all possible cases. If FE_Q and FE_RaviartThomas
* elements are included in the FECollection and both properly implement
/**
- * Blocked matrix class. The behaviour of objects of this type is almost as
+ * Blocked matrix class. The behavior of objects of this type is almost as
* for the usual matrix objects, with most of the functions being implemented
* in both classes. The main difference is that the matrix represented by this
* object is composed of an array of matrices (e.g. of type
* a preconditioner then the preconditioning operation is not a linear
* operation. Here a flexible solver like SolverFGMRES (flexible GMRES) is
* best employed as an outer solver in order to deal with the variable
- * behaviour of the preconditioner. Otherwise the iterative solver can
+ * behavior of the preconditioner. Otherwise the iterative solver can
* stagnate somewhere near the tolerance of the preconditioner or generally
* behave erratically. Alternatively, using a ReductionControl would ensure
* that the preconditioner always solves to the same tolerance, thereby
- * rendering its behaviour constant.
+ * rendering its behavior constant.
*
* Further examples of this functionality can be found in the test-suite, such
* as <code>tests/lac/schur_complement_01.cc</code> . The solution of a multi-
/**
* SLEPc solvers will want to have an MPI communicator context over which
* computations are parallelized. By default, this carries the same
- * behaviour as the PETScWrappers, but you can change that.
+ * behavior as the PETScWrappers, but you can change that.
*/
SolverKrylovSchur(SolverControl & cn,
const MPI_Comm & mpi_communicator = PETSC_COMM_SELF,
/**
* SLEPc solvers will want to have an MPI communicator context over which
* computations are parallelized. By default, this carries the same
- * behaviour as the PETScWrappers, but you can change that.
+ * behavior as the PETScWrappers, but you can change that.
*/
SolverArnoldi(SolverControl & cn,
const MPI_Comm & mpi_communicator = PETSC_COMM_SELF,
/**
* SLEPc solvers will want to have an MPI communicator context over which
* computations are parallelized. By default, this carries the same
- * behaviour as the PETScWrappers, but you can change that.
+ * behavior as the PETScWrappers, but you can change that.
*/
SolverLanczos(SolverControl & cn,
const MPI_Comm & mpi_communicator = PETSC_COMM_SELF,
/**
* SLEPc solvers will want to have an MPI communicator context over which
* computations are parallelized. By default, this carries the same
- * behaviour as the PETScWrappers, but you can change that.
+ * behavior as the PETScWrappers, but you can change that.
*/
SolverPower(SolverControl & cn,
const MPI_Comm & mpi_communicator = PETSC_COMM_SELF,
/**
* SLEPc solvers will want to have an MPI communicator context over which
* computations are parallelized. By default, this carries the same
- * behaviour as the PETScWrappers, but you can change that.
+ * behavior as the PETScWrappers, but you can change that.
*/
SolverGeneralizedDavidson(
SolverControl & cn,
/**
* SLEPc solvers will want to have an MPI communicator context over which
* computations are parallelized. By default, this carries the same
- * behaviour as the PETScWrappers, but you can change that.
+ * behavior as the PETScWrappers, but you can change that.
*/
SolverJacobiDavidson(SolverControl & cn,
const MPI_Comm &mpi_communicator = PETSC_COMM_SELF,
/**
* SLEPc solvers will want to have an MPI communicator context over which
* computations are parallelized. By default, this carries the same
- * behaviour as the PETScWrappers, but you can change that.
+ * behavior as the PETScWrappers, but you can change that.
*/
SolverLAPACK(SolverControl & cn,
const MPI_Comm & mpi_communicator = PETSC_COMM_SELF,
* waste some memory, so keep this in mind. However, if <tt>N==0</tt> all
* memory is freed, i.e. if you want to resize the vector and release the
* memory not needed, you have to first call <tt>reinit(0)</tt> and then
- * <tt>reinit(N)</tt>. This cited behaviour is analogous to that of the
+ * <tt>reinit(N)</tt>. This cited behavior is analogous to that of the
* standard library containers.
*
* If @p omit_zeroing_entries is false, the vector is filled by zeros.
/**
* Compute the time difference to the last time step. If this timestep is
* the first one, this function will result in an exception. Though this
- * behaviour seems a bit drastic, it is appropriate in most cases since if
+ * behavior seems a bit drastic, it is appropriate in most cases since if
* there is no previous time step you will need special treatment anyway and
* this way no invalid value is returned which could lead to wrong but
* unnoticed results of your computation. (The only sensible value to return
* change in the grids between subsequent time levels, while also trying to
* retain the freedom of refining each grid separately. There are lots of
* flags and numbers controlling this function, which might drastically change
- * the behaviour of the function -- see the description of the flags for
+ * the behavior of the function -- see the description of the flags for
* further information.
*/
template <int dim>
/**
* Constructor. Takes a coarse grid from which the grids on this time level
- * will be derived and some flags steering the behaviour of this object.
+ * will be derived and some flags steering the behavior of this object.
*
* The ownership of the coarse grid stays with the creator of this object.
* However, it is locked from destruction to guarantee the lifetime of the
* Triangulation used at this time level. Since this is something that every
* time stepping scheme needs to have, we can safely put it into the base
* class. Note that the triangulation is frequently deleted and rebuilt by
- * the functions @p sleep and @p wake_up to save memory, if such a behaviour
+ * the functions @p sleep and @p wake_up to save memory, if such a behavior
* is specified in the @p flags structure.
*/
SmartPointer<Triangulation<dim, dim>, TimeStepBase_Tria<dim>> tria;
* a parameter file using `prm`. The values of the parameter will be
* updated whenever the content of `prm` is updated.
*
- * Make sure that this class lives longer than `prm`. Undefined behaviour
+ * Make sure that this class lives longer than `prm`. Undefined behavior
* will occur if you destroy this class, and then parse a parameter file
* using `prm`.
*/
* a parameter file using `prm`. The values of the parameter will be
* updated whenever the content of `prm` is updated.
*
- * Make sure that this class lives longer than `prm`. Undefined behaviour
+ * Make sure that this class lives longer than `prm`. Undefined behavior
* will occur if you destroy this class, and then parse a parameter file
* using `prm`.
*/
* a parameter file using `prm`. The values of the parameter will be
* updated whenever the content of `prm` is updated.
*
- * Make sure that this class lives longer than `prm`. Undefined behaviour
+ * Make sure that this class lives longer than `prm`. Undefined behavior
* will occur if you destroy this class, and then parse a parameter file
* using `prm`.
*/
# ifdef DEBUG
# ifdef DEAL_II_WITH_MPI
// check that every process has decided to use the same mode. This will
- // otherwise result in undefined behaviour in the call to
+ // otherwise result in undefined behavior in the call to
// GlobalAssemble().
double double_mode = mode;
const Epetra_MpiComm *comm_ptr =
// refinement; in this case it often
// happens that the number of cells
// does not grow between sweeps, which
- // clearly is not the wanted behaviour)
+ // clearly is not the wanted behavior)
//
// however, if we do not do anything, we
// can get into trouble somewhen later.
//
// Test GeometryInfo<dim>::face_to_cell_vertices
-// for correct behaviour under face_orientation face_flip and face_rotation
+// for correct behavior under face_orientation face_flip and face_rotation
//
// dealii::AffineConstraints<double> &,
// const std::vector<bool> &,
// bool, bool, bool)
-// for correct behaviour on non standard oriented meshes.
+// for correct behavior on non standard oriented meshes.
//
// dealii::AffineConstraints<double> &,
// const std::vector<bool> &,
// bool, bool, bool)
-// for correct behaviour on non standard oriented meshes.
+// for correct behavior on non standard oriented meshes.
//
// a redux of why the 21_b test failed starting in r29525. in essence,
// what it boils down is that the new code did not implement the
// dealii::AffineConstraints<double> &,
// const std::vector<bool> &,
// bool, bool, bool)
-// for correct behaviour on non standard oriented meshes.
+// for correct behavior on non standard oriented meshes.
//
// like _21_b_x but use a Q3 element. For this, the face_flip has a
// tricky component in that we need not only flip the two vertics of
// dealii::AffineConstraints<double> &,
// const std::vector<bool> &,
// bool, bool, bool)
-// for correct behaviour on non standard oriented meshes.
+// for correct behavior on non standard oriented meshes.
//
// like _21_b_x, but with a once refined mesh
// const std::vector<bool> &,
// bool, bool, bool)
//
-// for correct behaviour with hanging nodes. This is done by additionally
+// for correct behavior with hanging nodes. This is done by additionally
// refining the second cube once. Test that constraining face_1 -> face_2
// and the opposite direction face_2 -> face_1 give the exact same result.
//
//
// This test was written by Sam Cox.
-// Tests the behaviour of DoFTools::make_flux_sparsity_pattern (DoFHandler,
+// Tests the behavior of DoFTools::make_flux_sparsity_pattern (DoFHandler,
// SparsityPattern, AffineConstraints<double>, bool,
// coupling, flux_coupling, subdomain_id)
deallog << "full h&p flags" << std::endl;
{
- deallog << " default behaviour: ";
+ deallog << " default behavior: ";
{
Triangulation<dim> tria;
hp::DoFHandler<dim> dh;
deallog << "full p flags" << std::endl;
{
- deallog << " default behaviour: ";
+ deallog << " default behavior: ";
{
Triangulation<dim> tria;
hp::DoFHandler<dim> dh;
deallog << "full h flags" << std::endl;
{
- deallog << " default behaviour: ";
+ deallog << " default behavior: ";
{
Triangulation<dim> tria;
hp::DoFHandler<dim> dh;
DEAL:1d::starting situation: ncells: 2 fe_indices: 0 0
DEAL:1d::full h&p flags
-DEAL:1d:: default behaviour: ncells: 1 fe_indices: 1
+DEAL:1d:: default behavior: ncells: 1 fe_indices: 1
DEAL:1d:: force p over h : ncells: 2 fe_indices: 1 1
DEAL:1d:: choose p over h : ncells: 2 fe_indices: 1 1
DEAL:1d::full p flags
-DEAL:1d:: default behaviour: ncells: 2 fe_indices: 1 1
+DEAL:1d:: default behavior: ncells: 2 fe_indices: 1 1
DEAL:1d:: force p over h : ncells: 2 fe_indices: 1 1
DEAL:1d:: choose p over h : ncells: 2 fe_indices: 1 1
DEAL:1d::full h flags
-DEAL:1d:: default behaviour: ncells: 1 fe_indices: 1
+DEAL:1d:: default behavior: ncells: 1 fe_indices: 1
DEAL:1d:: force p over h : ncells: 2 fe_indices: 0 1
DEAL:1d:: choose p over h : ncells: 1 fe_indices: 0
DEAL:1d::OK
DEAL:2d::starting situation: ncells: 4 fe_indices: 0 0 0 0
DEAL:2d::full h&p flags
-DEAL:2d:: default behaviour: ncells: 1 fe_indices: 1
+DEAL:2d:: default behavior: ncells: 1 fe_indices: 1
DEAL:2d:: force p over h : ncells: 4 fe_indices: 1 1 1 1
DEAL:2d:: choose p over h : ncells: 4 fe_indices: 1 1 1 1
DEAL:2d::full p flags
-DEAL:2d:: default behaviour: ncells: 4 fe_indices: 1 1 1 1
+DEAL:2d:: default behavior: ncells: 4 fe_indices: 1 1 1 1
DEAL:2d:: force p over h : ncells: 4 fe_indices: 1 1 1 1
DEAL:2d:: choose p over h : ncells: 4 fe_indices: 1 1 1 1
DEAL:2d::full h flags
-DEAL:2d:: default behaviour: ncells: 1 fe_indices: 1
+DEAL:2d:: default behavior: ncells: 1 fe_indices: 1
DEAL:2d:: force p over h : ncells: 4 fe_indices: 0 1 1 1
DEAL:2d:: choose p over h : ncells: 1 fe_indices: 0
DEAL:2d::OK
DEAL:3d::starting situation: ncells: 8 fe_indices: 0 0 0 0 0 0 0 0
DEAL:3d::full h&p flags
-DEAL:3d:: default behaviour: ncells: 1 fe_indices: 1
+DEAL:3d:: default behavior: ncells: 1 fe_indices: 1
DEAL:3d:: force p over h : ncells: 8 fe_indices: 1 1 1 1 1 1 1 1
DEAL:3d:: choose p over h : ncells: 8 fe_indices: 1 1 1 1 1 1 1 1
DEAL:3d::full p flags
-DEAL:3d:: default behaviour: ncells: 8 fe_indices: 1 1 1 1 1 1 1 1
+DEAL:3d:: default behavior: ncells: 8 fe_indices: 1 1 1 1 1 1 1 1
DEAL:3d:: force p over h : ncells: 8 fe_indices: 1 1 1 1 1 1 1 1
DEAL:3d:: choose p over h : ncells: 8 fe_indices: 1 1 1 1 1 1 1 1
DEAL:3d::full h flags
-DEAL:3d:: default behaviour: ncells: 1 fe_indices: 1
+DEAL:3d:: default behavior: ncells: 1 fe_indices: 1
DEAL:3d:: force p over h : ncells: 8 fe_indices: 0 1 1 1 1 1 1 1
DEAL:3d:: choose p over h : ncells: 1 fe_indices: 0
DEAL:3d::OK
-// check correct behaviour of Trilinos ghosted vectors
+// check correct behavior of Trilinos ghosted vectors
// create distributed and copy into ghosted...
#include <deal.II/base/index_set.h>
-// check correct behaviour of Trilinos ghosted vectors
+// check correct behavior of Trilinos ghosted vectors
#include <deal.II/base/index_set.h>
#include <deal.II/base/utilities.h>
-// check correct behaviour of Trilinos ghosted vectors. The
+// check correct behavior of Trilinos ghosted vectors. The
// test now checks that v.l2_norm() and v(idx)=... is disabled.
#include <deal.II/base/index_set.h>
-// check correct behaviour of Trilinos ghosted vectors
+// check correct behavior of Trilinos ghosted vectors
// check if assignment from a normal vector works correctly and updates the
// ghost values
-// check correct behaviour of reinit of Trilinos vectors
+// check correct behavior of reinit of Trilinos vectors
#include <deal.II/base/index_set.h>
#include <deal.II/base/utilities.h>
projects / dealii.git / commitdiff