oomph Namespace Reference

DRAIG: Change all instances of (SPATIAL_DIM) to (DIM-1). More...

Namespaces
namespace	ANSIEscapeCode
	Contains an enumeration of the ANSI escape codes used for colouring text (when piped to the command line). Adapted from the guide on: https://stackoverflow.com/questions/2616906/how-do-i-output- coloured-text-to-a-linux-terminal?utm_medium=organic&utm_source= google_rich_qa&utm_campaign=google_rich_qa Here, \033 is the ESC character, ASCII 27. It is followed by [, then zero or more numbers separated by ;, and finally the letter m. The numbers describe the colour and format to switch to from that point onwards.
namespace	AxisymmetricLinearElasticityTractionElementHelper
	Namespace containing the zero traction function for axisymmetric linear elasticity traction elements.
namespace	AxisymmetricNavierStokesTractionElementHelper
	Namespace containing the zero traction function for axisymmetric Navier Stokes traction elements.
namespace	AxisymmetricPoroelasticityTractionElementHelper
	Namespace containing the zero pressure function for Darcy pressure elements.
namespace	Biharmonic_schur_complement_Hypre_defaults
namespace	BinaryTreeNames
	Namespace for BinaryTree directions.
namespace	BlackBoxFDNewtonSolver
	Namespace for black-box FD Newton solver.
namespace	BrickFromTetMeshHelper
	Helper namespace for generation of brick from tet mesh.
namespace	BrokenCopy
	Namespace for error messages for broken copy constructors and assignment operators.
namespace	CommandLineArgs
	Namespace for command line arguments.
namespace	CRDoubleMatrixHelpers
	Namespace for helper functions for CRDoubleMatrices.
namespace	CumulativeTimings
	Namespace for global (cumulative) timings.
namespace	DarcyFaceElementHelper
	Namespace containing the zero pressure function for Darcy pressure elements.
namespace	DebugHelpers
	Namespace for debugging helpers. Currently only contains a function to prett-ify file name and line numbers (in red) to use when debugging. Makes it easy to identify where a std::cout statement was called.
namespace	DoubleVectorHelpers
	Namespace for helper functions for DoubleVectors.
namespace	ElementGeometry
	Enumeration a finite element's geometry "type". Either "Q" (square, cubeoid like) or "T" (triangle, tetrahedron).
namespace	ExactPreconditionerFactory
	Namespace containing functions required to create exact preconditioner.
namespace	FSI_functions
	Namespace for "global" FSI functions.
namespace	Global_output_stream
	Namespace containing an output stream that can be used for debugging. Use at your own risk – global data is evil!
namespace	Global_string_for_annotation
	Namespace containing a vector of strings that can be used to to store global output modifiers. This is global data and you use it at your own risk!
namespace	Global_timings
	===================================================================== Namespace to control level of comprehensive timings
namespace	Global_unsigned
	Namespace containing a number that can be used to annotate things for debugging. Use at your own risk – global data is evil!
namespace	Hankel_functions_for_helmholtz_problem
	Namespace to provide Hankel function of the first kind and various orders – needed for Helmholtz computations.
namespace	Helper_namespace_for_mesh_smoothing
	Helper namespace.
namespace	Hypre_default_settings
	Default settings for various uses of the HYPRE solver.
namespace	HypreHelpers
	Helper functions for use with the Hypre library.
namespace	HypreSubsidiaryPreconditionerHelper
	Helper method for the block diagonal F block preconditioner to allow hypre to be used as a subsidiary block preconditioner.
namespace	Lagrange_Enforced_Flow_Preconditioner_Subsidiary_Operator_Helper
	Namespace for subsidiary preconditioner creation helper functions.
namespace	LeakCheckNames
	Namespace for leak check: Keep a running count of all instantiated objects – add your own if you want to...
namespace	Legendre_functions_helper
	Helper namespace for functions required for Helmholtz computations.
namespace	LinearAlgebraDistributionHelpers
	Namespace for helper functions for LinearAlgebraDistributions.
namespace	LinearElasticityTractionElementHelper
	Namespace containing the zero traction function for linear elasticity traction elements.
namespace	LinearisedAxisymPoroelasticBJS_FSIHelper
	Namespace containing the default Strouhal number of axisymmetric linearised poroelastic FSI.
namespace	LinearisedFSIAxisymmetricNStNoSlipBCHelper
	Namespace containing the default Strouhal number of axisymmetric linearised FSI.
namespace	Locate_zeta_helpers
	Helper namespace for tolerances, number of iterations, etc used in the locate_zeta function in FiniteElement.
namespace	MathematicalConstants
	Namespace for mathematical constants.
namespace	MemoryUsage
	Namespace with helper functions to assess total memory usage on the fly using system() – details are very machine specific! This just provides the overall machinery with default settings for our own (linux machines). Uses the system command to spawn a command that computes the total memory usage on the machine where this is called. [Disclaimer: works on my machine(s) – no guarantees for any other platform; linux or not. MH].
namespace	MeshAsGeomObject_Helper
	Helper namespace for MeshAsGeomObject – its only function creates SamplePointContainerParameters of the right type for the default sample point container.
namespace	MeshChecker
	Namespace with helper function to check element type in mesh constructors (say).
namespace	MeshExtrusionHelpers
namespace	METIS
	Namespace for METIS graph partitioning routines.
namespace	Missing_masters_functions
namespace	Multi_domain_functions
namespace	MultiDomainBoussinesqHelper
	Namespace for default parameters in multi-domain Boussinesq.
namespace	NodeOrdering
namespace	ObsoleteCode
	Namespace for flagging up obsolete parts of the code.
namespace	OcTreeNames
namespace	OneDimDiscontinuousGalerkin
	One dimensional shape functions and derivatives. Empty – simply establishes the template parameters.
namespace	OneDimDiscontinuousGalerkinMixedOrderBasis
	One dimensional shape functions and derivatives. Empty – simply establishes the template parameters.
namespace	OneDimDiscontinuousGalerkinMixedOrderTest
	One dimensional shape functions and derivatives. Empty – simply establishes the template parameters.
namespace	OneDimHermite
	One Dimensional Hermite shape functions.
namespace	OneDimLagrange
namespace	Orthpoly
namespace	ParaviewHelper
	Namespace for paraview-style output helper functions.
namespace	PauseFlags
	Namespace for pause() command.
namespace	PMLTimeHarmonicLinearElasticityTractionElementHelper
	Namespace containing the zero traction function for linear elasticity traction elements.
namespace	PoroelasticityFaceElementHelper
	Namespace containing the zero pressure function for Darcy pressure elements.
namespace	PreconditionerCreationFunctions
namespace	PressureAdvectionDiffusionValidation
	Namespace for exact solution for pressure advection diffusion problem.
namespace	Pseudo_Elastic_Preconditioner_Subsidiary_Operator_Helper
	Functions to create instances of optimal subsidiary operators for the PseudoElasticPreconditioner.
namespace	PseudoSolidHelper
	Helper namespace for pseudo-elastic elements.
namespace	QElement1BulkCoordinateDerivatives
	Namespace for helper functions that calculate derivatives of the local coordinates in the bulk elements wrt the local coordinates in the face element.
namespace	QElement1FaceToBulkCoordinates
	Namespace for helper functions that return the local coordinates in the bulk elements.
namespace	QElement2BulkCoordinateDerivatives
	Namespace for helper functions that calculate derivatives of the local coordinates in the bulk elements wrt the local coordinates in the face element.
namespace	QElement2FaceToBulkCoordinates
	Namespace for the functions that translate local face coordinates to the coordinates in the bulk element.
namespace	QElement3BulkCoordinateDerivatives
	Namespace for helper functions that calculate derivatives of the local coordinates in the bulk elements wrt the local coordinates in the face element.
namespace	QElement3FaceToBulkCoordinates
	Namespace for the functions that translate local face coordinates to the coordinates in the bulk element.
namespace	QuadTreeNames
	Namespace for QuadTree directions.
namespace	RRR
namespace	SecondInvariantHelper
	Helper namespace containing function that computes second invariant of tensor.
namespace	SolidHelpers
	Namespace for solid mechanics helper functions.
namespace	SolidTractionElementHelper
	Namespace containing the zero traction function for solid traction elements.
namespace	StringConversion
	Conversion functions for easily making strings (e.g. for filenames - to avoid stack smashing problems with cstrings and long filenames).
namespace	TecplotNames
	Namespace for tecplot stuff.
namespace	TElement1BulkCoordinateDerivatives
	Namespace for helper functions that calculate derivatives of the local coordinates in the bulk elements wrt the local coordinates in the face element.
namespace	TElement1FaceToBulkCoordinates
	Namespace for helper functions that return the local coordinates in the bulk elements.
namespace	TElement2BulkCoordinateDerivatives
	Namespace for helper functions that calculate derivatives of the local coordinates in the bulk elements wrt the local coordinates in the face element.
namespace	TElement2FaceToBulkCoordinates
	Namespace for the functions that translate local face coordinates to the coordinates in the bulk element.
namespace	TElement3FaceToBulkCoordinates
	Namespace for the functions that translate local face coordinates to the coordinates in the bulk element.
namespace	TerminateHelper
	Helper namespace for set_terminate function – used to spawn.
namespace	TimeHarmonicFourierDecomposedLinearElasticityTractionElementHelper
	Namespace containing the zero traction function for time-harmonic Fourier decomposed linear elasticity traction elements.
namespace	TimeHarmonicLinearElasticityTractionElementHelper
	Namespace containing the zero traction function for linear elasticity traction elements.
namespace	TimingHelpers
	Helper for recording execution time.
namespace	ToleranceForFourierDecomposedHelmholtzOuterBoundary
	Namespace for checking radius of nodes on (assumed to be circular) DtN boundary.
namespace	ToleranceForHelmholtzOuterBoundary
	Namespace for checking radius of nodes on (assumed to be circular) DtN boundary.
namespace	ToleranceForVertexMismatchInPolygons
	Namespace that allows the specification of a tolerance between vertices at the ends of polylines that are supposed to be at the same position.
namespace	TriangleBoundaryHelper
	Helper namespace for BCInfo object used in the identification of boundary elements.
namespace	TriangleHelper
	Helper namespace for triangle meshes.
namespace	TrilinosEpetraHelpers
	Helper namespace for use with the Trilinos Epetra package. Contains functions to generate two Epetra containers (Epetra_Vector and Epetra_CrsMatrix) and provides access to the trilinos matrix-matrix and matrix-vector product routines.
namespace	TwoDimensionalPMLHelper
	Namespace with functions that allow the construction of PML layers on axis aligned boundaries.
namespace	TypeNames
namespace	VectorHelpers
	Namespace for helper functions for Vector<double>
namespace	VorticityRecoveryHelpers
	Namespace with helper functions for (2D) vorticity (and derivatives) recovery.

Classes
class	AbsCmp
	Function-type-object to perform absolute comparison of objects. Apparently this inlines better. More...
class	AddedMainNumberingLookup
	Class to store bi-directional lookup between added matrix row/col numbers to main matrix (SumOfMatrix) row/col numbers. More...
class	AdjointProblemBasedShiftInvertOperator
	Class for the adjoing problem shift invert operation. More...
class	AdvectionDiffusionBoussinesqElement
	Build AdvectionDiffusionBoussinesqElement that inherits from ElementWithExternalElement so that it can "communicate" with the Navier Stokes element. More...
class	AdvectionDiffusionEquations
	A class for all elements that solve the Advection Diffusion equations using isoparametric elements. More...
class	AdvectionDiffusionFluxElement
	A class for elements that allow the imposition of an applied flux on the boundaries of Advection Diffusion elements. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	AdvectionDiffusionReactionEquations
	A class for all elements that solve the Advection Diffusion Reaction equations using isoparametric elements. More...
class	AlgebraicChannelWithLeafletMesh
	Algebraic version of ChannelWithLeafletMesh. Leaflet is assumed to be in its undeformed (straight vertical) position when the algebraic node update is set up. More...
class	AlgebraicCollapsibleChannelMesh
	Collapsible channel mesh with algebraic node update. More...
class	AlgebraicCylinderWithFlagMesh
	Algebraic version of CylinderWithFlagMesh. More...
class	AlgebraicElement
	Algebraic elements are elements that have AlgebraicNodes whose position is determined by the geometric Data in the GeomObjects that are involved in their node update functions. Algebraic Elements include the derivatives w.r.t. any unknowns that are stored in this geometric Data into the element's Jacobian matrix. Otherwise they behave exactly like the templace element. More...
class	AlgebraicElementBase
	Base class for algebraic elements. More...
class	AlgebraicFishMesh
	Fish shaped mesh with algebraic node update function for nodes. More...
class	AlgebraicFSIDrivenCavityMesh
	/ Alebraic node update version of FSIDrivenCavityMesh More...
class	AlgebraicMesh
	Algebraic meshes contain AlgebraicElements and AlgebraicNodes. They implement the node update functions that are used by the AlgebraicNodes to update their positions. More...
class	AlgebraicNode
	Algebraic nodes are nodes with an algebraic positional update function. More...
class	AlgebraicRefineableFishMesh
	Refineable fish shaped mesh with algebraic node update function. More...
class	AlgebraicRefineableQuarterCircleSectorMesh
	Algebraic version of RefineableQuarterCircleSectorMesh. More...
class	AlgebraicRefineableQuarterTubeMesh
	AlgebraicMesh version of RefineableQuarterTubeMesh. More...
class	ANASAZI
	Class for the Anasazi eigensolver. More...
class	AnnularDomain
	Annular domain. More...
class	AssemblyHandler
	A class that is used to define the functions used to assemble the elemental contributions to the residuals vector and Jacobian matrix that define the problem being solved. The main use of this class is to assemble and solve the augmented systems used in bifurcation detection and tracking. The default implementation merely calls the underlying elemental functions with no augmentation. More...
class	AugmentedBlockFoldLinearSolver
	A custom linear solver class that is used to solve a block-factorised version of the Fold bifurcation detection problem. More...
class	AugmentedBlockPitchForkLinearSolver
	A custom linear solver class that is used to solve a block-factorised version of the PitchFork bifurcation detection problem. More...
class	AugmentedProblemGMRES
	The GMRES method. More...
class	AxisymAdvectionDiffusionEquations
	A class for all elements that solve the Advection Diffusion equations in a cylindrical polar coordinate system using isoparametric elements. More...
class	AxisymDiagHermitePVDElement
	An element that solved the AxisymmetricPVDEquations with (diagonal) Hermite interpolation for the positions – the local and global (Lagrangian) coordinates are assumed to be aligned! More...
class	AxisymFoepplvonKarmanElement
	Axisym FoepplvonKarmanElement elements are 1D Foeppl von Karman elements with isoparametric interpolation for the function. More...
class	AxisymFoepplvonKarmanEquations
	A class for all isoparametric elements that solve the axisYm Foeppl von Karman equations in a displacement based formulation. More...
class	AxisymmetricDerivatives
	Class that establishes the surface derivative functions for AxisymmetricInterfaceElements. These are defined in a separate class so that they can be used by other interface equation-type classes. More...
class	AxisymmetricLinearElasticityEquations
	A class for elements that solve the axisymmetric (in cylindrical polars) equations of linear elasticity. More...
class	AxisymmetricLinearElasticityEquationsBase
	A base class for elements that solve the axisymmetric (in cylindrical polars) equations of linear elasticity. More...
class	AxisymmetricLinearElasticityTractionElement
	A class for elements that allow the imposition of an applied traction in the equations of axisymmetric linear elasticity. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	AxisymmetricNavierStokesEquations
	A class for elements that solve the unsteady axisymmetric Navier–Stokes equations in cylindrical polar coordinates, and with . We're solving for the radial, axial and azimuthal (swirl) velocities, and , respectively, and the pressure . This class contains the generic maths – any concrete implementation must be derived from this. More...
class	AxisymmetricNavierStokesTractionElement
	A class for elements that allow the imposition of an applied traction in the axisym Navier Stokes eqns. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	AxisymmetricPoroelasticityEquations
	Class implementing the generic maths of the axisym poroelasticity equations: axisym linear elasticity coupled with axisym Darcy equations (using Raviart-Thomas elements with both edge and internal degrees of freedom) including inertia in both. More...
class	AxisymmetricPoroelasticityTractionElement
	A class for elements that allow the imposition of an applied combined traction and pore fluid pressure in the axisym poroelasticity equations. The geometrical information can be read from the FaceGeometry<ELEMENT> class and thus, we can be generic enough without the need to have a separate equations class. More...
class	AxisymmetricPVDEquations
	A class for elements that solve the equations of solid mechanics, based on the principle of virtual displacements in an axisymmetric formulation. In this case x[0] is the component of displacement in the radial direction and x[1] is that in the theta direction. More...
class	AxisymmetricPVDEquationsWithPressure
	A class for elements that solve the equations of solid mechanics, based on the principle of virtual displacements in axisymmetric coordinates in a formulation that allows for incompressibility or near incompressibility. More...
class	AxisymmetricQCrouzeixRaviartElement
	Crouzeix_Raviart elements are Navier–Stokes elements with quadratic interpolation for velocities and positions, but a discontinuous linear pressure interpolation. More...
class	AxisymmetricQTaylorHoodElement
	Taylor–Hood elements are Navier–Stokes elements with quadratic interpolation for velocities and positions and continous linear pressure interpolation. More...
class	AxisymmetricSolidTractionElement
	A class for elements that allow the imposition of an applied traction in the principle of virtual displacements. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	AxisymmetricTCrouzeixRaviartElement
	AxisymmetricTCrouzeix_Raviart elements are Navier–Stokes elements with quadratic interpolation for velocities and positions enriched by a single cubic bubble function, but a discontinuous linear pressure interpolation. More...
class	AxisymmetricTTaylorHoodElement
	Taylor–Hood elements are Navier–Stokes elements with quadratic interpolation for velocities and positions and continous linear pressure interpolation. More...
class	AxisymmetricVolumeConstraintBoundingElement
	Axisymmetric (one-dimensional) interface elements that allow the application of a volume constraint on the region bounded by these elements. The volume is computed by integrating x.n around the boundary of the domain and then dividing by three. The sign is chosen so that the volume will be positive when the elements surround a fluid domain. More...
class	AxisymQPVDElement
	An element that solved the AxisymmetricPVDEquations with quadratic interpolation for the positions. More...
class	AxisymQPVDElementWithPressure
	An Element that solves the Axisymmetric principle of virtual displacements with separately interpolated pressure, discontinuous interpolation. More...
class	BackupMeshForProjection
	Class that makes backup (via a deep copy) of a mesh, keeping alive enough information to allow the solution that is currently stored on the mesh to be projected onto another mesh sometime in the future (when the original mesh may already have been deleted). This is mainly useful for the projection of additional nodal values (such as Lagrange multipliers) created by FaceElements. ASSUMPTION: All fields in the element are represented by isoparametric Lagrange interpolation between the nodal values. Any fields that do not fall into this category will not be copied across correctly and if you're unlucky the code may die...). More...
class	BackwardStepQuadMesh
	Backward step mesh. More...
class	BandedBlockTriangularPreconditioner
	General purpose block triangular preconditioner. By default this operates as an upper triangular preconditioner. Also, by default ExactPreconditioner is used to solve the subsidiary systems, but other preconditioners can be used by setting them using passing a pointer to a function of type SubsidiaryPreconditionerFctPt to the method subsidiary_preconditioner_function_pt(). More...
class	BDF
	Templated class for BDF-type time-steppers with fixed or variable timestep. 1st time derivative recovered directly from the previous function values. Template parameter represents the number of previous timesteps stored, so that BDF<1> is the classical first order backward Euler scheme. Need to reset weights after every change in timestep. More...
class	BermudezPMLMapping
	A mapping function propsed by Bermudez et al, appears to be the best for the Helmholtz equations and so this will be the default mapping (see definition of PmlHelmholtzEquations) More...
class	BermudezPMLMappingAndTransformedCoordinate
	The mapping function propsed by Bermudez et al, appears to be the best and so this will be the default mapping (see definition of PMLHelmholtzEquations) More...
class	BiCGStab
	The conjugate gradient method. More...
class	BiharmonicElement
	biharmonic element class More...
class	BiharmonicEquations
	Biharmonic Equation Class - contains the equations. More...
class	BiharmonicFluidBoundaryElement
	Point equation element used to impose the traction free edge (i.e. du/dn = 0) on the boundary when dt/ds_n != 0. The following equation is implemented : du/ds_n = dt/ds_n * ds_t/dt * du/dt. The bulk biharmonic elements on the boundary must be hijackable and the du/ds_n and d2u/ds_nds_t boundary DOFs hijacked when these elements are applied. At any node where dt/ds_n = 0 we can impose du/ds_n = 0 and d2u/ds_nds_t = 0 using pinning - see BiharmonicFluidProblem::impose_traction_free_edge() More...
class	BiharmonicFluidProblem
	Biharmonic Fluid Problem Class - describes stokes flow in 2D. Developed for the topologically rectangular Hermite Element Mesh. Contains functions allowing the following boundary conditions to be applied (on a given edge): More...
class	BiharmonicFluxElement
	Biharmonic Flux Element. More...
class	BiharmonicPreconditioner
	Biharmonic Preconditioner - for two dimensional problems. More...
class	BiharmonicProblem
	Biharmonic Plate Problem Class - for problems where the load can be assumed to be acting normal to the surface of the plate and the deflections are small relative to the thickness of the plate. Developed for the topologically rectangular Hermite Element Mesh. Contains functions allowing the following boundary conditions to be applied (on a given edge): More...
class	BinArrayParameters
	Helper object for dealing with the parameters used for the BinArray objects. More...
class	BinaryTree
	BinaryTree class: Recursively defined, generalised binary tree. More...
class	BinaryTreeForest
	A BinaryTreeForest consists of a collection of BinaryTreeRoots. Each member tree can have neighbours to its left and right. More...
class	BinaryTreeRoot
	BinaryTreeRoot is a BinaryTree that forms the root of a (recursive) binary tree. The "root node" is special as it holds additional information about its neighbours. More...
class	BlockAntiDiagonalPreconditioner
	Block "anti-diagonal" preconditioner, i.e. same as block diagonal but along the other diagonal of the matrix (top-right to bottom-left). More...
class	BlockDiagonalPreconditioner
	Block diagonal preconditioner. By default SuperLU is used to solve the subsidiary systems, but other preconditioners can be used by setting them using passing a pointer to a function of type SubsidiaryPreconditionerFctPt to the method subsidiary_preconditioner_function_pt(). More...
class	BlockHopfLinearSolver
	A custom linear solver class that is used to solve a block-factorised version of the Hopf bifurcation detection problem. More...
class	BlockPitchForkLinearSolver
	A custom linear solver class that is used to solve a block-factorised version of the PitchFork bifurcation detection problem. More...
class	BlockPreconditionableSpaceTimeElementBase
	Block preconditionable space-time element base class. NOTE: It has to derive from GeneralisedElement so that it can overload the implementation of ndof_types() in GeneralisedElement. More...
class	BlockPreconditioner
	Block Preconditioner base class. The block structure of the overall problem is determined from the Mesh's constituent elements. Each constituent element must be block-preconditionable - i.e must implement the GeneralisedElements functions ndof_types() and get_dof_numbers_for_unknowns(...). A Problem can have several Meshes, but each Mesh must contain elements with the same DOF types. The association between global degrees of freedom and their unique local dof numbers is therefore based on information provided by the elements. We refer to the local dof numbers provided by the elements as the elemental dof numbers. More...
class	BlockPrecQTaylorHoodMixedOrderSpaceTimeElement
	Block preconditionable version of the QTaylorHoodMixedOrderSpaceTimeElement. More...
class	BlockPrecQUnsteadyHeatMixedOrderSpaceTimeElement
	Block preconditionable version of UnsteadyHeatMixedOrderSpaceTimeElement. More...
class	BlockPrecQUnsteadyHeatSpaceTimeElement
	Block preconditionable version of UnsteadyHeatSpaceTimeElement. More...
class	BlockPrecRefineableQUnsteadyHeatMixedOrderSpaceTimeElement
	Block preconditionable version of UnsteadyHeatSpaceTimeElement. More...
class	BlockPrecRefineableQUnsteadyHeatSpaceTimeElement
	Block preconditionable version of UnsteadyHeatSpaceTimeElement. More...
class	BlockSelector
	Data structure to store information about a certain "block" or sub-matrix from the overall matrix in the block preconditioning framework. More...
class	BlockTriangularPreconditioner
	General purpose block triangular preconditioner By default this is Upper triangular. By default ExactPreconditioner is used to solve the subsidiary systems, but other preconditioners can be used by setting them using passing a pointer to a function of type SubsidiaryPreconditionerFctPt to the method subsidiary_preconditioner_function_pt(). More...
class	BoundaryNode
	A template Class for BoundaryNodes; that is Nodes that MAY live on the boundary of a Mesh. The class is formed by a simple composition of the template parameter NODE_TYPE, which must be a Node class and the BoundaryNodeBase class. Final overloading of functions is always in favour of the BoundaryNodeBase implementation; i.e. these nodes can live on boundaries. More...
class	BoundaryNodeBase
	A class that contains the information required by Nodes that are located on Mesh boundaries. A BoundaryNode of a particular type is obtained by combining a given Node with this class. By differentiating between Nodes and BoundaryNodes we avoid a lot of un-necessary storage in the bulk Nodes. More...
class	BoundingElementType
	This policy class is used to associate specific bounding elements with specific FluidInterface elements. It must be filled in for every class that uses the SpineUpdateFluidInterface<...> or ElasticUpdateFluidInterface<....> generic template classes. Examples for our default Line, Axisymmetric and Surface types are included below. More...
class	BoundingElementType< ElasticUpdateFluidInterfaceElement< FluidInterfaceElement, AxisymmetricDerivatives, ELEMENT > >
class	BoundingElementType< ElasticUpdateFluidInterfaceElement< FluidInterfaceElement, LineDerivatives, ELEMENT > >
	Define the BoundingElement type associated with the 1D surface element. More...
class	BoundingElementType< ElasticUpdateFluidInterfaceElement< FluidInterfaceElement, SurfaceDerivatives, ELEMENT > >
class	BoundingElementType< ElasticUpdateFluidInterfaceElement< SurfactantTransportInterfaceElement, AxisymmetricDerivatives, ELEMENT > >
class	BoundingElementType< SpineUpdateFluidInterfaceElement< FluidInterfaceElement, AxisymmetricDerivatives, ELEMENT > >
class	BoundingElementType< SpineUpdateFluidInterfaceElement< FluidInterfaceElement, LineDerivatives, ELEMENT > >
class	BoundingElementType< SpineUpdateFluidInterfaceElement< FluidInterfaceElement, SurfaceDerivatives, ELEMENT > >
class	BoundingElementType< SpineUpdateFluidInterfaceElement< SurfactantTransportInterfaceElement, AxisymmetricDerivatives, ELEMENT > >
class	BoundingElementType< SpineUpdateFluidInterfaceElement< SurfactantTransportInterfaceElement, LineDerivatives, ELEMENT > >
class	BoundingElementType< SpineUpdateFluidInterfaceElement< SurfactantTransportInterfaceElement, SurfaceDerivatives, ELEMENT > >
class	BrethertonSpineMesh
	Mesh for 2D Bretherton problem – based on single layer mesh. Templated by spine-ified Navier-Stokes element type (e.g. SpineElement<QCrouzeixRaviartElement<2> > and the corresponding interface element (e.g. SpineLineFluidInterfaceElement<SpineElement<QCrouzeixRaviartElement<2> > > More...
class	BrickElementBase
	Base class for all brick elements. More...
class	BrickFromTetMesh
	Brick mesh built by brickifying an existing tet mesh – each tet gets split into four bricks. Can only be built with quadratic (27 node) elements. More...
class	BrickMeshBase
	Base class for brick meshes (meshes made of 3D brick elements). More...
class	BuoyantQCrouzeixRaviartElement
	A class that solves the Boussinesq approximation of the Navier–Stokes and energy equations by coupling two pre-existing classes. The QAdvectionDiffusionElement with bi-quadratic interpolation for the scalar variable (temperature) and QCrouzeixRaviartElement which solves the Navier–Stokes equations using bi-quadratic interpolation for the velocities and a discontinuous bi-linear interpolation for the pressure. Note that we are free to choose the order in which we store the variables at the nodes. In this case we choose to store the variables in the order fluid velocities followed by temperature. We must, therefore, overload the function AdvectionDiffusionEquations<DIM>::u_index_adv_diff() to indicate that the temperature is stored at the DIM-th position not the 0-th. We do not need to overload the corresponding function in the NavierStokesEquations<DIM> class because the velocities are stored first. More...
class	CassonTanMilRegWithBlendingConstitutiveEquation
	A GeneralisedNewtonianConstitutiveEquation class defining a Casson model fluid using Tanner and Milthorpe's (1983) regularisation with a smooth transition using a cubic. More...
class	CCComplexMatrix
	A class for compressed column matrices that store doubles. More...
class	CCDoubleMatrix
	A class for compressed column matrices that store doubles. More...
class	CCMatrix
	A class for compressed column matrices: a sparse matrix format The class is passed as the MATRIX_TYPE paramater so that the base class can use the specific access functions in the round-bracket operator. More...
class	CG
	The conjugate gradient method. More...
class	CGALSamplePointContainerParameters
	Helper object for dealing with the parameters used for the CGALSamplePointContainer objects. More...
class	ChannelSpineMesh
	Spine mesh class derived from standard 2D mesh. The mesh contains a StraightLine GeomObject which defines the height of the left and right regions (0,2) and another GeomObject is passed to the constructor to define the height in the central region. More...
class	ChannelWithLeafletDomain
	Rectangular domain with a leaflet blocking the lower half. More...
class	ChannelWithLeafletMesh
	Channel with leaflet mesh. More...
class	Circle
	Circle in 2D space. More...
class	CircularCylindricalShellMesh
	A 2D solid mesh for (topologically) circular cylindrical shells. The shell is represented by two Lagrangian coordinates that correspond to z and theta in cylindrical polars. The required mesh is therefore a 2D mesh and is therefore inherited from the generic RectangularQuadMesh. More...
class	ClampedHermiteShellBoundaryConditionElement
	Element that allows the imposition of boundary conditions for a shell that is clamped to a 2D plane that is specified by its normal. Constraint is applied by a Lagrange multiplier. Note 1: Note that the introduction of the Lagrange multiplier adds two additional values (relative to the number of values before the addition of the FaceElement) to the nodes. This ensures that nodes that are shared by adjacent FaceElements are not resized repeatedly but also means that this won't work if two "edges" of the shell (that share a node) are subject to different constraints, each applied with its own independent Lagrange multiplier. In such cases a modified version of this class must be written. Note 2: The FaceGeometry for a HermiteShellElement is the 1D two-node element SolidQHermiteElement<1> which has four shape functions (two nodes, two types – representing the shape functions that interpolate the value and the derivative). These are the "correct" shape functions for the interpolation of the Lagrange multiplier and the isoparametric representation of the geometry. However, when applying the contribution from the constraint equation to the bulk equations, we have to take all four types of dof into account so the element has to reset the number of positional dofs to four. To avoid any clashes we overload (the relevant subset of) the access functions to the shape functions and their derivatives and set the shape functions associated with the spurious positional dofs to zero. This is a bit hacky but the only way (?) this can be done... More...
class	ClampedSlidingHermiteBeamBoundaryConditionElement
	Element that allows the imposition of boundary conditions for a beam that is clamped but can slide along a line which is specified by a position vector to that line and the normal vector to it. The endpoint of the beam is forced to stay on that line and meet it at a right angle. This is achieved with Lagrange multipliers. More...
struct	classcomp
class	CollapsibleChannelDomain
	Collapsible channel domain. More...
class	CollapsibleChannelMesh
	Basic collapsible channel mesh. The mesh is derived from the SimpleRectangularQuadMesh so it's node and element numbering scheme is the same as in that mesh. Only the boundaries are numbered differently to allow the easy identification of the "collapsible" segment. Boundary coordinates are set up for all nodes located on boundary 3 (the collapsible segment). The curvilinear ("collapsible") segment is defined by a GeomObject. More...
class	CompareBoundaryCoordinate
	A class to do comparison of the elements by lexicographic ordering, based on the boundary coordinates at the element's first node. More...
class	ComplexDampedJacobi
	Damped Jacobi "solver" templated by matrix type. The "solver" exists in many different incarnations: It's an IterativeLinearSolver, and a Smoother, all of which use the same basic iteration. More...
class	ComplexGMRES
	The GMRES method rewritten for complex matrices. More...
class	ComplexMatrixBase
	Abstract base class for matrices of complex doubles – adds abstract interfaces for solving, LU decomposition and multiplication by vectors. More...
class	CompressedMatrixCoefficient
	Class for a compressed-matrix coefficent (for either CC or CR matrices). Contains the (row or column) index and value of a coefficient in a compressed row or column. Currently only used in ILU(0) for CCDoubleMatrices to allow the coefficients in each compressed column [row] to be sorted by their row [column] index. More...
class	ConstitutiveLaw
	A class for constitutive laws for elements that solve the equations of solid mechanics based upon the principle of virtual displacements. In that formulation, the information required from a constitutive law is the (2nd Piola-Kirchhoff) stress tensor as a function of the (Green) strain : More...
class	ContinuationStorageScheme
	GeneralisedTimestepper used to store the arclength derivatives and pervious solutions required in continuation problems. The data is stored as auxilliary data in the (fake) TimeStepper so that spatial adaptivity will be handled automatically through our standard mechanisms. The adopted storage scheme is that the continuation derivatives will be stored at the first auxilliary value and the previous value will be the second auixilliary value. More...
class	ContinuousBermudezPMLMapping
	A mapping function proposed by Bermudez et al, similar to the one above but is continuous across the inner Pml boundary appears to be the best for TimeHarmonicLinearElasticity and so this will be the default mapping. More...
class	CopiedData
	Custom Data class that is used when making a shallow copy of a data object. The class contains a copy of an entire other Data object. More...
class	CRComplexMatrix
	A class for compressed row matrices. More...
class	CRDoubleMatrix
	A class for compressed row matrices. This is a distributable object. More...
class	CRMatrix
	A class for compressed row matrices, a sparse storage format Once again the recursive template trick is used to inform that base class that is should use the access functions provided in the CRMatrix class. More...
class	CylinderWithFlagDomain
	Domain for cylinder with flag as in Turek benchmark. More...
class	CylinderWithFlagMesh
	Domain-based mesh for cylinder with flag as in Turek benchmark. More...
class	DampedJacobi
	Damped Jacobi "solver" templated by matrix type. The "solver" exists in many different incarnations: It's an IterativeLinearSolver, and a Smoother, all of which use the same basic iteration. More...
class	DarcyEquations
	Class implementing the generic maths of the Darcy equations using Raviart-Thomas elements with both edge and internal degrees of freedom. More...
class	DarcyFaceElement
	A class for elements that allow the imposition of an applied pressure in the Darcy equations. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	Data
	A class that represents a collection of data; each Data object may contain many different individual values, as would be natural in non-scalar problems. Data provides storage for auxiliary ‘history’ values that are used by TimeStepper objects to calculate the time derivatives of the stored data and also stores a pointer to the appropriate TimeStepper object. In addition, an associated (global) equation number is stored for each value. More...
class	DenseComplexMatrix
	Class of matrices containing double complex, and stored as a DenseMatrix<complex<double> >, but with solving functionality inherited from the abstract ComplexMatrix class. More...
class	DenseDoubleMatrix
	Class of matrices containing doubles, and stored as a DenseMatrix<double>, but with solving functionality inherited from the abstract DoubleMatrix class. More...
class	DenseLU
	Dense LU decomposition-based solve of full assembled linear system. VERY inefficient but useful to illustrate the principle. Only suitable for use with Serial matrices and vectors. This solver will only work with non-distributed matrices and vectors (note: DenseDoubleMatrix is not distributable) More...
class	DenseMatrix
	Class for dense matrices, storing all the values of the matrix as a pointer to a pointer with assorted output functions inherited from Matrix<T>. The curious recursive template pattern is used here to pass the specific class to the base class so that round bracket access can be inlined. More...
class	DeviatoricIsotropicElasticityTensor
	An isotropic elasticity tensor defined in terms of Young's modulus and Poisson's ratio. The elasticity tensor is assumed to be non-dimensionalised on some reference value for Young's modulus so the value provided to the constructor (if any) is to be interpreted as the ratio of the actual Young's modulus to the Young's modulus used to non-dimensionalise the stresses/tractions in the governing equations. More...
class	DGElement
	A Base class for DGElements. More...
class	DGEulerFaceElement
	FaceElement for Discontinuous Galerkin Problems. More...
class	DGEulerFaceReflectionElement
	FaceElement for Discontinuous Galerkin Problems with reflection boundary conditions. More...
class	DGFaceElement
	Base class for Discontinuous Galerkin Faces. These are responsible for calculating the normal fluxes that provide the communication between the discontinuous elements. More...
class	DGMesh
class	DGScalarAdvectionElement
	General DGScalarAdvectionClass. Establish the template parameters. More...
class	DGScalarAdvectionElement< 1, NNODE_1D >
class	DGScalarAdvectionElement< 2, NNODE_1D >
	Specialisation for 2D DG Elements. More...
class	DGScalarAdvectionFaceElement
	FaceElement for Discontinuous Galerkin Problems. More...
class	DGSpectralEulerElement
	General DGEulerClass. Establish the template parameters. More...
class	DGSpectralEulerElement< 1, NNODE_1D >
class	DGSpectralEulerElement< 2, NNODE_1D >
	Specialisation for 2D DG Elements. More...
class	DGSpectralScalarAdvectionElement
	General DGScalarAdvectionClass. Establish the template parameters. More...
class	DGSpectralScalarAdvectionElement< 1, NNODE_1D >
class	DGSpectralScalarAdvectionElement< 2, NNODE_1D >
	Specialisation for 2D DG Elements. More...
class	DiagHermiteShellElement
	An element that solves the Kirchhoff-Love shell theory equations using Hermite interpolation (displacements and slopes are interpolated separately. The local and global (Lagrangian) coordinates are assumed to be aligned so that the Jacobian of the mapping between these coordinates is diagonal. This significantly simplifies (and speeds up) the computation of the derivatives of the shape functions. More...
class	DiagQHermiteElement
	These elements are exactly the same as QHermiteElements, but they employ the simplifying assumption that the local and global coordinates are aligned. This makes the evaluation of the derivatives of the shape functions much cheaper. More...
class	DiskLikeGeomObjectWithBoundaries
	Base class for upgraded disk-like GeomObject (i.e. 2D surface in 3D space) with specification of boundaries. The GeomObject's position(...) function computes the 3D (Eulerian) position vector r as a function of the 2D intrinsic (Lagrangian) coordinates, zeta, without reference to any boundaries. This class specifies the boundaries by specifying a mapping from a 1D intrinsic boundary coordinate, zeta_bound, to the 2D intrinsic (Lagrangian) coordinates, zeta. More...
class	DisplacementBasedFoepplvonKarmanEquations
	A class for all isoparametric elements that solve the Foeppl von Karman equations. More...
class	DisplacementControlElement
	Displacement control element: In the "normal" formulation of solid mechanics problems, the external load is given and the displacement throughout the solid body is computed. For highly nonlinear problems it is sometimes helpful to re-formulate the problem by prescribing the position of a selected control point and treating the (scalar) load level required to achieve this deformation as an unknown. As an example consider the buckling of pressure-loaded, thin-walled elastic shells. The load-displacement characteristics of such structures tend to be highly nonlinear and bifurcations from the structure's pre-buckling state often occur via sub-critical bifurcations. If we have some a-priori knowledge of the expected deformation (for example, during the non-axisymmetric buckling of a circular cylindrical shell certain material points will be displaced radially inwards), it is advantageous to prescribe the radial displacement of a carefully selected control point and treat the external pressure as an unknown. More...
class	DistributableLinearAlgebraObject
	Base class for any linear algebra object that is distributable. Just contains storage for the LinearAlgebraDistribution object and access functions. More...
class	DistributionPredicate
	Class to allow sorting of column indices in conversion to epetra matrix. More...
class	DocInfo
	Information for documentation of results: Directory and file number to enable output in the form RESLT/filename11.dat, say. Documentation can be switched on and off. More...
class	DocLinearSolverInfo
	Collection of data structures for storing information about linear solves. Currently only contains storage for the iteration counts and the linear solver time. More...
class	Domain
	Base class for Domains with curvilinear and/or time-dependent boundaries. Domain boundaries are typically represented by GeomObject s and the Domain itself is decomposed into a number of MacroElement s as shown in this 2D example: More...
class	DoubleMatrixBase
	Abstract base class for matrices of doubles – adds abstract interfaces for solving, LU decomposition and multiplication by vectors. More...
class	DoubleMultiVector
	A multi vector in the mathematical sense, initially developed for linear algebra type applications. If MPI then this multi vector can be distributed - its distribution is described by the LinearAlgebraDistribution object at Distribution_pt. Data is stored in a C-style pointer vector (double*) More...
class	DoubleMultiVectorOperator
	Base class for Oomph-lib's Vector Operator classes that will be used with the DoubleMultiVector. More...
class	DoubleVector
	A vector in the mathematical sense, initially developed for linear algebra type applications. If MPI then this vector can be distributed - its distribution is described by the LinearAlgebraDistribution object at Distribution_pt. Data is stored in a C-style pointer vector (double*) More...
class	DoubleVectorHaloScheme
	A class that stores the halo/haloed entries required when using a DoubleVectorWithHaloEntries. This is a separate class so thay many different Vectors can share the same object. The constructor requires the distribution of the DoubleVector (if you pass in a different distribution things will go badly wrong) and a vector that specifies which GLOBAL eqn numbers are required on each processor. More...
class	DoubleVectorWithHaloEntries
	===================================================================== An extension of DoubleVector that allows access to certain global entries that are not stored locally. Synchronisation of these values must be performed manually by calling the synchronise() function. Synchronisation can only be from the haloed to the halo, but the local halo entries can all be summed and stored in the More...
class	DShape
	A Class for the derivatives of shape functions The class design is essentially the same as Shape, but there is on additional index that is used to indicate the coordinate direction in which the derivative is taken. More...
class	DummyAlgebraicMesh
	Dummy algebraic mesh – used for default assignements. More...
class	DummyBlockPreconditioner
	Preconditioner that doesn't actually do any preconditioning, it just allows access to the Jacobian blocks. This is pretty hacky but oh well.. More...
class	DummyBrickElement
	Dummy QElement to interpolate local coordinates – used in construction of brickified tet mesh. More...
class	DummyErrorEstimator
	Dummy error estimator, allows manual specification of refinement pattern by forcing refinement in regions defined by elements in a reference mesh. More...
class	DummyFaceElement
	Dummy FaceElement for use with purely geometric operations such as mesh generation. More...
class	DummyMesh
	Dummy mesh that can be created and deleted in SolidICProblem. More...
class	EBDF3
	=========================================================== An explicit version of BDF3 (i.e. uses derivative evaluation at y_n instead of y_{n+1}). Useful as a predictor because it is third order accurate but requires only one function evaluation (i.e. only one mass matrix inversion + residual calculation). More...
class	Edge
	Edge class. More...
class	EigenProblemHandler
	A class that is used to define the functions used to assemble the elemental contributions to the mass matrix and jacobian (stiffness) matrix that define a generalised eigenproblem. More...
class	EigenSolver
	Base class for all EigenProblem solves. This simply defines standard interfaces so that different solvers can be used easily. More...
class	EighthSphereDomain
	Eighth sphere as domain. Domain is parametrised by four macro elements. More...
class	EighthSphereMesh
	Eight of a sphere brick mesh, based on the EightSphereDomain Non-refineable version with four brick elements. The eighth-sphere is located in the positive octant, centred at the origin. The mesh boundaries are numbered as follows: More...
class	ElasticAxisymmetricFluidInterfaceElement
	Specialise the Elastic update case to axisymmetric equations. More...
class	ElasticAxisymmetricSurfactantTransportInterfaceElement
	Specialise to the Axisymmetric geometry. More...
class	ElasticAxisymmetricVolumeConstraintBoundingElement
	The axisymmetric (one-dimensional) interface elements that allow imposition of a volume constraint specialised for the case when the nodal positions of the bulk elements are treated as solid degrees of freedom. To enforce that a fluid volume has a certain volume, attach these elements to all faces of the (2D axisymmetric) bulk fluid elements (of type ELEMENT) that bound that region and then specify the "pressure" value that is traded for the constraint. More...
class	ElasticityTensor
	A base class that represents the fourth-rank elasticity tensor defined such that. More...
class	ElasticLineFluidInterfaceBoundingElement
	Pseudo-elasticity version of the LineFluidInterfaceBoundingElement. More...
class	ElasticLineFluidInterfaceElement
	Specialise the elastic update template class to concrete 1D case. More...
class	ElasticLineVolumeConstraintBoundingElement
	The one-dimensional interface elements that allow imposition of a volume constraint specialised for the case when the nodal positions of the bulk elements are treated as solid degrees of freedom. To enforce that a fluid volume has a certain volume, attach these elements to all faces of the (2D cartesian) bulk fluid elements (of type ELEMENT) that bound that region and then specify the "pressure" value that is traded for the constraint. More...
class	ElasticPointFluidInterfaceBoundingElement
	Pseudo-elasticity version of the PointFluidInterfaceBoundingElement. More...
class	ElasticQuarterPipeMesh
	Non refineable elastic quarter pipe mesh class setup lagrangian coordinates for solid mechanics problems. More...
class	ElasticRectangularQuadMesh
	Elastic quad mesh with functionality to attach traction elements to the specified boundaries. We "upgrade" the RectangularQuadMesh to become an SolidMesh and equate the Eulerian and Lagrangian coordinates, thus making the domain represented by the mesh the stress-free configuration. More...
class	ElasticRefineableQuarterPipeMesh
	Refineable elastic quarter pipe mesh class. More...
class	ElasticRefineableRectangularQuadMesh
	Elastic refineable quad mesh with functionality to attach traction elements to the specified boundaries. We "upgrade" the RefineableRectangularQuadMesh to become an SolidMesh and equate the Eulerian and Lagrangian coordinates, thus making the domain represented by the mesh the stress-free configuration. We also move the mesh "down" by half the the "height" so x=0 is located on the centreline – appropriate for the beam-type problems for which this mesh was developed. More...
class	ElasticSurfaceFluidInterfaceElement
	Specialise Elastic update case to the concrete 2D case. More...
class	ElasticSurfaceVolumeConstraintBoundingElement
	The Two-dimensional interface elements that allow the application of a volume constraint specialised for the case when the nodal positions of the bulk elements are treated as solid degrees of freedom. To enforce that a fluid volume has a certain volume, attach these elements to all faces of the (3D Cartesian) bulk fluid elements (of type ELEMENT) that bound that region and then specify the "pressure" value that is traded for the constraint. More...
class	ElasticUpdateFluidInterfaceElement
	Generic Elastic node update interface template class that can be combined with a given surface equations class and surface derivative class to provide a concrete implementation of any surface element that uses elastic node updates. More...
class	ElementWithDragFunction
	Base class for elements that can specify a drag and torque (about the origin) – typically used for immersed particle computations. More...
class	ElementWithExternalElement
	This is a base class for all elements that require external sources (e.g. FSI, multi-domain problems such as Helmholtz, multi-mesh Boussinesq convection, etc.). It provides storage for the source element and corresponding local coordinate at each integration point, and allows use of locate_zeta to obtain such source elements. In addition separate storage is allocated for all field data in the external elements and all geometric data that can affect the field data in the external elements. Generic finite difference routines are provided to calculate entries in the Jacobian from the data of the external elements. More...
class	ElementWithMovingNodes
	A policy class that serves to establish the common interfaces for elements that contain moving nodes. This class provides storage for the geometric data that affect the update of all the nodes of the element, i.e. USUALLY all data that are using during a call to the Element's node_update() function. In some cases (e.g. FluidInterfaceEdge elements), node_update() is overloaded to perform an update of the bulk element, in which case the additional bulk geometric data become external data of the element and the function GeneralisedElement::update_in_external_fd(i) is overloaded to also perform the bulk node update. The storage is populated during the assignment of the equation numbers via the complete_setup_of_dependencies() function and then local equations numbers are assigned to these data, accessible via geometric_data_local_eqn(n,i). Finally, a function is provided that calculates the terms in the jacobian matrix by due to these geometric data by finite differences. More...
class	ElementWithSpecificMovingNodes
	Specific implementation of the class for specified element and node type. More...
class	ElementWithZ2ErrorEstimator
	Base class for finite elements that can compute the quantities that are required for the Z2 error estimator. More...
class	Ellipse
	Steady ellipse with half axes A and B as geometric object: More...
class	EllipticalTube
	Elliptical tube with half axes a and b. More...
class	ErrorEstimator
	Base class for spatial error estimators. More...
class	Euler
	=========================================================== Simple first-order Euler Timestepping More...
class	EulerEquations
	Base class for Euler equations. More...
class	ExactBlockPreconditioner
	Exact block preconditioner - block preconditioner assembled from all blocks associated with the preconditioner and solved by SuperLU. More...
class	ExactDGPBlockPreconditioner
	General purpose block tridiagonal preconditioner. By default ExactPreconditioner is used to solve the subsidiary systems, but other preconditioners can be used by setting them using passing a pointer to a function of type SubsidiaryPreconditionerFctPt to the method subsidiary_preconditioner_function_pt(). More...
class	ExactSubBiharmonicPreconditioner
	Sub Biharmonic Preconditioner - an exact preconditioner for the 3x3 top left hand corner sub block matrix. Used as part of the BiharmonicPreconditioner<MATRIX> . By default this uses the BBD (block-bordered-diagonal/arrow-shaped) preconditioner; can also switch to full BD version (in which case all the 3x3 blocks are retained) More...
class	ExplicitTimeStepHandler
	A class that is used to define the functions used to assemble and invert the mass matrix when taking an explicit timestep. The idea is simply to replace the jacobian matrix with the mass matrix and then our standard linear solvers will solve the required system. More...
class	ExplicitTimeSteppableObject
	Class for objects than can be advanced in time by an Explicit Timestepper. WARNING: For explicit time stepping to work the object's residual function (as used by get_inverse_mass_matrix_times_residuals(..)) MUST be in the form r = f(t, u) - [timestepper approximation to dudt]! Standard implicit time stepping will work with plenty of residuals that don't fit into this form. Some examples where implicit time stepping will work fine but explicit will fail: 1) The negation of the above formula, this implementation will end up using dudt = - f(u,t). 2) A residual which is implicit or non-linear in dudt, such as r = dudt. More...
class	ExplicitTimeStepper
	A Base class for explicit timesteppers. More...
class	ExtrudedCubeMeshFromQuadMesh
	Mesh class that takes a 2D mesh consisting of quadrilateral elements and "extrudes" it in the z-direction. More...
class	ExtrudedDomain
	Base class for ExtrudedDomains with curvilinear and/or time-dependent boundaries. ExtrudedDomain boundaries are typically represented by GeomObjects and the ExtrudedDomain itself is decomposed into a number of ExtrudedMacroElements. Any instantiation of a specific ExtrudedDomain needs to implement the pure virtual member function. More...
class	ExtrudedMacroElement
	DRAIG: FILL IN COMPLETE DESCRIPTION ONCE FINISHED... More...
class	FaceElement
	FaceElements are elements that coincide with the faces of higher-dimensional "bulk" elements. They are used on boundaries where additional non-trivial boundary conditions need to be applied. Examples include free surfaces, and applied traction conditions. In many cases, FaceElements need to evaluate to quantities in the associated bulk elements. For instance, the evaluation of a shear stresses on 2D FaceElement requires the evaluation of velocity derivatives in the associated 3D volume element etc. Therefore we store a pointer to the associated bulk element, and information about the relation between the local coordinates in the face and bulk elements. More...
class	FaceElementAsGeomObject
	Class that is used to create FaceElement from bulk elements and to provide these FaceElement with a geometric object representation. The local coordinates of the FaceElements are used as the intrinisic coordinates for its GeomObject representation. More...
class	FaceGeometry
	FaceGeometry class definition: This policy class is used to allow construction of face elements that solve arbitrary equations without having to tamper with the corresponding "bulk" elements. The geometrical information for the face element must be specified by each "bulk" element using an explicit specialisation of this class. More...
class	FaceGeometry< AlgebraicElement< ELEMENT > >
	Explicit definition of the face geometry of algebraic elements: the same as the face geometry of the underlying element. More...
class	FaceGeometry< AxisymDiagHermitePVDElement >
	Explicit definition of the face geometry for the. More...
class	FaceGeometry< AxisymmetricQCrouzeixRaviartElement >
	Face geometry of the Axisymmetric Crouzeix_Raviart elements. More...
class	FaceGeometry< AxisymmetricQTaylorHoodElement >
	Face geometry of the Axisymmetric Taylor_Hood elements. More...
class	FaceGeometry< AxisymmetricTCrouzeixRaviartElement >
	Face geometry of the 2D Crouzeix_Raviart elements. More...
class	FaceGeometry< AxisymmetricTTaylorHoodElement >
	Face geometry of the Axisymmetric Taylor_Hood elements. More...
class	FaceGeometry< AxisymQPVDElement >
class	FaceGeometry< AxisymQPVDElementWithPressure >
class	FaceGeometry< BiharmonicElement< 1 > >
class	FaceGeometry< BiharmonicElement< DIM > >
	face geometry for biharmonic elements - template parameter indicates dimension of problem (i.e. bulk element), not the face elements More...
class	FaceGeometry< BuoyantQCrouzeixRaviartElement< DIM > >
	Face geometry of the 2D Buoyant Crouzeix_Raviart elements. More...
class	FaceGeometry< DGScalarAdvectionElement< 1, NNODE_1D > >
	Face geometry of the 1D DG elements. More...
class	FaceGeometry< DGScalarAdvectionElement< 2, NNODE_1D > >
	Face geometry of the DG elements. More...
class	FaceGeometry< DGSpectralEulerElement< 1, NNODE_1D > >
	Face geometry of the 1D DG elements. More...
class	FaceGeometry< DGSpectralEulerElement< 2, NNODE_1D > >
	Face geometry of the DG elements. More...
class	FaceGeometry< DGSpectralScalarAdvectionElement< 1, NNODE_1D > >
	Face geometry of the 1D DG elements. More...
class	FaceGeometry< DGSpectralScalarAdvectionElement< 2, NNODE_1D > >
	Face geometry of the DG elements. More...
class	FaceGeometry< FaceGeometry< AxisymmetricQCrouzeixRaviartElement > >
	Face geometry of face geometry of the Axisymmetric Crouzeix_Raviart elements. More...
class	FaceGeometry< FaceGeometry< AxisymmetricQTaylorHoodElement > >
	Face geometry of the face geometry of the Axisymmetric Taylor_Hood elements. More...
class	FaceGeometry< FaceGeometry< AxisymmetricTCrouzeixRaviartElement > >
	Face geometry of the FaceGeometry of the 2D CrouzeixRaviart elements. More...
class	FaceGeometry< FaceGeometry< AxisymmetricTTaylorHoodElement > >
	Face geometry of the FaceGeometry of the Axisymmetric TaylorHood elements. More...
class	FaceGeometry< FaceGeometry< BuoyantQCrouzeixRaviartElement< 2 > > >
	Face geometry of the Face geometry of 2D Buoyant Crouzeix_Raviart elements. More...
class	FaceGeometry< FaceGeometry< FSIAxisymmetricQTaylorHoodElement > >
	Face geometry of the face geometry of the Axisymmetric Taylor_Hood elements. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement > >
	Face geometry of face geometry of the GeneralisedNewtonianAxisymmetric Crouzeix_Raviart elements. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianAxisymmetricQTaylorHoodElement > >
	Face geometry of the face geometry of the GeneralisedNewtonianAxisymmetric Taylor_Hood elements. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement > >
	Face geometry of the FaceGeometry of the 2D CrouzeixRaviart elements. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianAxisymmetricTTaylorHoodElement > >
	Face geometry of the FaceGeometry of the. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianProjectableAxisymmetricCrouzeixRaviartElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianProjectableAxisymmetricTaylorHoodElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianQCrouzeixRaviartElement< 2 > > >
	Face geometry of the FaceGeometry of the 2D Crouzeix_Raviart elements. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianQCrouzeixRaviartElement< 3 > > >
	Face geometry of the FaceGeometry of the 3D Crouzeix_Raviart elements. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianQTaylorHoodElement< 2 > > >
	Face geometry of the FaceGeometry of the 2D Taylor Hoodelements. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianQTaylorHoodElement< 3 > > >
	Face geometry of the FaceGeometry of the 3D Taylor_Hood elements. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianTCrouzeixRaviartElement< 2 > > >
	Face geometry of the FaceGeometry of the 2D CrouzeixRaviart elements. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianTCrouzeixRaviartElement< 3 > > >
	Face geometry of the FaceGeometry of the 3D Crouzeix_Raviart elements. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianTTaylorHoodElement< 2 > > >
	Face geometry of the FaceGeometry of the 2D TaylorHood elements. More...
class	FaceGeometry< FaceGeometry< GeneralisedNewtonianTTaylorHoodElement< 3 > > >
	Face geometry of the FaceGeometry of the 3D Crouzeix_Raviart elements. More...
class	FaceGeometry< FaceGeometry< Hijacked< ELEMENT > > >
	Explicit definition of the face geometry of hijacked elements: the same as the face geometry of the underlying element. More...
class	FaceGeometry< FaceGeometry< LinearisedAxisymmetricQCrouzeixRaviartElement > >
	Face geometry of face geometry of the linearised axisymmetric Crouzeix Raviart elements. More...
class	FaceGeometry< FaceGeometry< LinearisedAxisymmetricQTaylorHoodElement > >
	Face geometry of the face geometry of the linearised axisymmetric Taylor Hood elements. More...
class	FaceGeometry< FaceGeometry< LinearisedQCrouzeixRaviartElement > >
	Face geometry of face geometry of the linearised axisymmetric Crouzeix Raviart elements. More...
class	FaceGeometry< FaceGeometry< LinearisedQTaylorHoodElement > >
	Face geometry of the face geometry of the linearised axisymmetric Taylor Hood elements. More...
class	FaceGeometry< FaceGeometry< NavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT > > >
	Explicit definition of the face geometry of these elements. More...
class	FaceGeometry< FaceGeometry< ProjectableAdvectionDiffusionReactionElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableAxisymLinearElasticityElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableAxisymmetricCrouzeixRaviartElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableAxisymmetricTaylorHoodElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableCrouzeixRaviartElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableDisplacementBasedFoepplvonKarmanElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableFoepplvonKarmanElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableFourierDecomposedHelmholtzElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableGeneralisedNewtonianCrouzeixRaviartElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableGeneralisedNewtonianTaylorHoodElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableHelmholtzElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableLinearElasticityElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectablePMLFourierDecomposedHelmholtzElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectablePMLTimeHarmonicLinearElasticityElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectablePoissonElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectablePVDElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectablePVDElementWithContinuousPressure< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableTaylorHoodElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableTaylorHoodMixedOrderSpaceTimeElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableTimeHarmonicFourierDecomposedLinearElasticityElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableTimeHarmonicLinearElasticityElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableUnsteadyHeatElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableUnsteadyHeatMixedOrderSpaceTimeElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< ProjectableUnsteadyHeatSpaceTimeElement< ELEMENT > > >
	Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< FaceGeometry< PseudoSolidNodeUpdateElement< BASIC, SOLID > > >
	Explicit definition of the face geometry of these elements. More...
class	FaceGeometry< FaceGeometry< QCrouzeixRaviartElement< 2 > > >
	Face geometry of the FaceGeometry of the 2D Crouzeix_Raviart elements. More...
class	FaceGeometry< FaceGeometry< QCrouzeixRaviartElement< 3 > > >
	Face geometry of the FaceGeometry of the 3D Crouzeix_Raviart elements. More...
class	FaceGeometry< FaceGeometry< QPVDElement< 2, NNODE_1D > > >
	FaceGeometry of the FaceGeometry of the 2D QPVDElement. More...
class	FaceGeometry< FaceGeometry< QPVDElement< 3, NNODE_1D > > >
	FaceGeometry of FaceGeometry of a 3D QPVDElement element. More...
class	FaceGeometry< FaceGeometry< QPVDElementWithContinuousPressure< 2 > > >
	FaceGeometry of FaceGeometry for 2D QPVDElementWithContinuousPressure element. More...
class	FaceGeometry< FaceGeometry< QPVDElementWithContinuousPressure< 3 > > >
	FaceGeometry of FaceGeometry for 3D QPVDElementWithContinuousPressure element. More...
class	FaceGeometry< FaceGeometry< QPVDElementWithPressure< 2 > > >
	FaceGeometry of FaceGeometry of 2D QPVDElementWithPressure. More...
class	FaceGeometry< FaceGeometry< QPVDElementWithPressure< 3 > > >
	FaceGeometry of FaceGeometry of 3D QPVDElementWithPressure. More...
class	FaceGeometry< FaceGeometry< QSphericalCrouzeixRaviartElement > >
	Face geometry of the FaceGeometry of the Spherical Crouzeix_Raviart elements. More...
class	FaceGeometry< FaceGeometry< QSphericalTaylorHoodElement > >
	Face geometry of the FaceGeometry of the 2D Taylor Hoodelements. More...
class	FaceGeometry< FaceGeometry< QTaylorHoodElement< 2 > > >
	Face geometry of the FaceGeometry of the 2D Taylor Hoodelements. More...
class	FaceGeometry< FaceGeometry< QTaylorHoodElement< 3 > > >
	Face geometry of the FaceGeometry of the 3D Taylor_Hood elements. More...
class	FaceGeometry< FaceGeometry< QTaylorHoodMixedOrderSpaceTimeElement< 2 > > >
	Face geometry of the FaceGeometry of the 2D Taylor Hoodelements. More...
class	FaceGeometry< FaceGeometry< RefineableAxisymmetricQCrouzeixRaviartElement > >
	Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
class	FaceGeometry< FaceGeometry< RefineableAxisymmetricQTaylorHoodElement > >
	Face geometry of the RefineableQuadQTaylorHoodElements. More...
class	FaceGeometry< FaceGeometry< RefineableGeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement > >
	Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
class	FaceGeometry< FaceGeometry< RefineableGeneralisedNewtonianAxisymmetricQTaylorHoodElement > >
	Face geometry of the RefineableQuadQTaylorHoodElements. More...
class	FaceGeometry< FaceGeometry< RefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM > > >
	Face geometry of the face geometry of the RefineableQCrouzeixRaviartElements is the same as the Face geometry of the Face geometry of QCrouzeixRaviartElements. More...
class	FaceGeometry< FaceGeometry< RefineableGeneralisedNewtonianQTaylorHoodElement< DIM > > >
	Face geometry of the face geometry of the RefineableQTaylorHoodElements is the same as the Face geometry of the Face geometry of QTaylorHoodElements. More...
class	FaceGeometry< FaceGeometry< RefineableLinearisedAxisymmetricQCrouzeixRaviartElement > >
	Face geometry of face geometric of the refineable linearised axisym Crouzeix-Raviart elements. More...
class	FaceGeometry< FaceGeometry< RefineableLinearisedAxisymmetricQTaylorHoodElement > >
	Face geometry of face geometric of the refineable linearised axisym Taylor-Hood elements. More...
class	FaceGeometry< FaceGeometry< RefineableLinearisedQCrouzeixRaviartElement > >
	Face geometry of face geometric of the refineable linearised axisym Crouzeix-Raviart elements. More...
class	FaceGeometry< FaceGeometry< RefineableLinearisedQTaylorHoodElement > >
	Face geometry of face geometric of the refineable linearised axisym Taylor-Hood elements. More...
class	FaceGeometry< FaceGeometry< RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID > > >
	Explicit definition of the face geometry of these elements. More...
class	FaceGeometry< FaceGeometry< RefineableQCrouzeixRaviartElement< DIM > > >
	Face geometry of the face geometry of the RefineableQCrouzeixRaviartElements is the same as the Face geometry of the Face geometry of QCrouzeixRaviartElements. More...
class	FaceGeometry< FaceGeometry< RefineableQLinearElasticityElement< 2, NNODE_1D > > >
	FaceGeometry of the FaceGeometry of the 2D RefineableQLinearElasticityElement. More...
class	FaceGeometry< FaceGeometry< RefineableQLinearElasticityElement< 3, NNODE_1D > > >
	FaceGeometry of the FaceGeometry of the 3D RefineableQLinearElasticityElement. More...
class	FaceGeometry< FaceGeometry< RefineableQPVDElement< 2, NNODE_1D > > >
	FaceGeometry of the FaceGeometry of the 2D RefineableQPVDElement. More...
class	FaceGeometry< FaceGeometry< RefineableQPVDElement< 3, NNODE_1D > > >
	FaceGeometry of the FaceGeometry of the 3D RefineableQPVDElement. More...
class	FaceGeometry< FaceGeometry< RefineableQPVDElementWithContinuousPressure< 2 > > >
	FaceGeometry of the FaceGeometry of the 2D RefineableQPVDElementWithContinuousPressure. More...
class	FaceGeometry< FaceGeometry< RefineableQPVDElementWithContinuousPressure< 3 > > >
	FaceGeometry of the FaceGeometry of the 3D RefineableQPVDElementWithContinuousPressue. More...
class	FaceGeometry< FaceGeometry< RefineableQPVDElementWithPressure< 2 > > >
	FaceGeometry of the FaceGeometry of the 2D RefineableQPVDElementWithPressure. More...
class	FaceGeometry< FaceGeometry< RefineableQPVDElementWithPressure< 3 > > >
	FaceGeometry of the FaceGeometry of the 3D RefineableQPVDElementWithPressure. More...
class	FaceGeometry< FaceGeometry< RefineableQSphericalCrouzeixRaviartElement > >
	Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
class	FaceGeometry< FaceGeometry< RefineableQSphericalTaylorHoodElement > >
	Face geometry of the RefineableQuadQTaylorHoodElements. More...
class	FaceGeometry< FaceGeometry< RefineableQTaylorHoodElement< DIM > > >
	Face geometry of the face geometry of the RefineableQTaylorHoodElements is the same as the Face geometry of the Face geometry of QTaylorHoodElements. More...
class	FaceGeometry< FaceGeometry< RefineableQTaylorHoodMixedOrderSpaceTimeElement< DIM > > >
	Face geometry of the face geometry of the RefineableQTaylorHoodMixedOrderSpaceTimeElements is the same as the Face geometry of the Face geometry of QTaylorHoodMixedOrderSpaceTimeElements. More...
class	FaceGeometry< FaceGeometry< RefineableQTimeHarmonicLinearElasticityElement< 2, NNODE_1D > > >
	FaceGeometry of the FaceGeometry of the 2D RefineableQTimeHarmonicLinearElasticityElement. More...
class	FaceGeometry< FaceGeometry< RefineableQTimeHarmonicLinearElasticityElement< 3, NNODE_1D > > >
	FaceGeometry of the FaceGeometry of the 3D RefineableQTimeHarmonicLinearElasticityElement. More...
class	FaceGeometry< FaceGeometry< SpineElement< ELEMENT > > >
	Explicit definition of the face geometry for spine elements: The same as the face geometry of the underlying element. More...
class	FaceGeometry< FaceGeometry< TCrouzeixRaviartElement< 2 > > >
	Face geometry of the FaceGeometry of the 2D CrouzeixRaviart elements. More...
class	FaceGeometry< FaceGeometry< TCrouzeixRaviartElement< 3 > > >
	Face geometry of the FaceGeometry of the 3D Crouzeix_Raviart elements. More...
class	FaceGeometry< FaceGeometry< TPVDBubbleEnrichedElement< 2, NNODE_1D > > >
	FaceGeometry of the FaceGeometry of the 2D TPVDBubbleEnrichedElement. More...
class	FaceGeometry< FaceGeometry< TPVDBubbleEnrichedElement< 3, NNODE_1D > > >
	FaceGeometry of FaceGeometry of a 3D TPVDElement element. More...
class	FaceGeometry< FaceGeometry< TPVDElement< 2, NNODE_1D > > >
	FaceGeometry of the FaceGeometry of the 2D TPVDElement. More...
class	FaceGeometry< FaceGeometry< TPVDElement< 3, NNODE_1D > > >
	FaceGeometry of FaceGeometry of a 3D TPVDElement element. More...
class	FaceGeometry< FaceGeometry< TTaylorHoodElement< 2 > > >
	Face geometry of the FaceGeometry of the 2D TaylorHood elements. More...
class	FaceGeometry< FaceGeometry< TTaylorHoodElement< 3 > > >
	Face geometry of the FaceGeometry of the 3D Crouzeix_Raviart elements. More...
class	FaceGeometry< FSIAxisymmetricQTaylorHoodElement >
	Face geometry of the Axisymmetric Taylor_Hood elements. More...
class	FaceGeometry< GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement >
	Face geometry of the GeneralisedNewtonianAxisymmetric Crouzeix_Raviart elements. More...
class	FaceGeometry< GeneralisedNewtonianAxisymmetricQTaylorHoodElement >
	Face geometry of the GeneralisedNewtonianAxisymmetric Taylor_Hood elements. More...
class	FaceGeometry< GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement >
	Face geometry of the 2D Crouzeix_Raviart elements. More...
class	FaceGeometry< GeneralisedNewtonianAxisymmetricTTaylorHoodElement >
	Face geometry of the GeneralisedNewtonianAxisymmetric Taylor_Hood elements. More...
class	FaceGeometry< GeneralisedNewtonianProjectableAxisymmetricCrouzeixRaviartElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< GeneralisedNewtonianProjectableAxisymmetricTaylorHoodElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< GeneralisedNewtonianQCrouzeixRaviartElement< 2 > >
	Face geometry of the 2D Crouzeix_Raviart elements. More...
class	FaceGeometry< GeneralisedNewtonianQCrouzeixRaviartElement< 3 > >
	Face geometry of the 3D Crouzeix_Raviart elements. More...
class	FaceGeometry< GeneralisedNewtonianQTaylorHoodElement< 2 > >
	Face geometry of the 2D Taylor_Hood elements. More...
class	FaceGeometry< GeneralisedNewtonianQTaylorHoodElement< 3 > >
	Face geometry of the 3D Taylor_Hood elements. More...
class	FaceGeometry< GeneralisedNewtonianTCrouzeixRaviartElement< 2 > >
	Face geometry of the 2D Crouzeix_Raviart elements. More...
class	FaceGeometry< GeneralisedNewtonianTCrouzeixRaviartElement< 3 > >
	Face geometry of the 3D Crouzeix_Raviart elements. More...
class	FaceGeometry< GeneralisedNewtonianTTaylorHoodElement< 2 > >
	Face geometry of the 2D Taylor_Hood elements. More...
class	FaceGeometry< GeneralisedNewtonianTTaylorHoodElement< 3 > >
	Face geometry of the 3D Taylor_Hood elements. More...
class	FaceGeometry< HermiteBeamElement >
	Face geometry for the HermiteBeam elements: Solid point element. More...
class	FaceGeometry< HermiteShellElement >
	Face geometry for the HermiteShell elements: 1D SolidQHermiteElement. More...
class	FaceGeometry< Hijacked< ELEMENT > >
	Explicit definition of the face geometry of hijacked elements: the same as the face geometry of the underlying element. More...
class	FaceGeometry< Hijacked< FaceGeometry< ELEMENT > > >
	Explicit definition of the face geometry of hijacked elements: the same as the face geometry of the underlying element. More...
class	FaceGeometry< LinearisedAxisymmetricQCrouzeixRaviartElement >
	Face geometry of the linearised axisym Crouzeix-Raviart elements. More...
class	FaceGeometry< LinearisedAxisymmetricQTaylorHoodElement >
	Face geometry of the linearised axisymmetric Taylor Hood elements. More...
class	FaceGeometry< LinearisedQCrouzeixRaviartElement >
	Face geometry of the linearised axisym Crouzeix-Raviart elements. More...
class	FaceGeometry< LinearisedQTaylorHoodElement >
	Face geometry of the linearised axisymmetric Taylor Hood elements. More...
class	FaceGeometry< MacroElementNodeUpdateElement< ELEMENT > >
	Explicit definition of the face geometry of MacroElementNodeUpdateElements, which is the same as the face geometry of the underlying element. More...
class	FaceGeometry< NavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT > >
	Explicit definition of the face geometry of these elements. More...
class	FaceGeometry< PMLLayerElement< TPMLHelmholtzElement< DIM, NNODE_1D > > >
	Face geometry for the TPMLHelmholtzElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< PMLLayerElement< TPMLTimeHarmonicLinearElasticityElement< DIM, NNODE_1D > > >
	Face geometry for the TPMLTimeHarmonicLinearElasticityElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< PolarCrouzeixRaviartElement >
	Face geometry of the 2D Crouzeix_Raviart elements. More...
class	FaceGeometry< PolarTaylorHoodElement >
	Face geometry of the 2D Taylor_Hood elements. More...
class	FaceGeometry< ProjectableAdvectionDiffusionReactionElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableAxisymLinearElasticityElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableAxisymmetricCrouzeixRaviartElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableAxisymmetricPoroelasticityElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableAxisymmetricTaylorHoodElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableCrouzeixRaviartElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableDarcyElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableDisplacementBasedFoepplvonKarmanElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableFoepplvonKarmanElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableFourierDecomposedHelmholtzElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableGeneralisedNewtonianCrouzeixRaviartElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableGeneralisedNewtonianTaylorHoodElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableHelmholtzElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableLinearElasticityElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectablePMLFourierDecomposedHelmholtzElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectablePMLHelmholtzElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectablePMLTimeHarmonicLinearElasticityElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectablePoissonElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectablePVDElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectablePVDElementWithContinuousPressure< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableTaylorHoodElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableTaylorHoodMixedOrderSpaceTimeElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableTimeHarmonicFourierDecomposedLinearElasticityElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableTimeHarmonicLinearElasticityElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableUnsteadyHeatElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableUnsteadyHeatMixedOrderSpaceTimeElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< ProjectableUnsteadyHeatSpaceTimeElement< ELEMENT > >
	Face geometry for element is the same as that for the underlying wrapped element. More...
class	FaceGeometry< PseudoSolidNodeUpdateElement< BASIC, SOLID > >
	Explicit definition of the face geometry of these elements. More...
class	FaceGeometry< QAdvectionDiffusionElement< 1, NNODE_1D > >
	Face geometry for the 1D QAdvectionDiffusion elements: Point elements. More...
class	FaceGeometry< QAdvectionDiffusionElement< DIM, NNODE_1D > >
	Face geometry for the QAdvectionDiffusionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QAdvectionDiffusionReactionElement< NREAGENT, 1, NNODE_1D > >
	Face geometry for the 1D QAdvectionDiffusionReaction elements: Point elements. More...
class	FaceGeometry< QAdvectionDiffusionReactionElement< NREAGENT, DIM, NNODE_1D > >
	Face geometry for the QAdvectionDiffusionReactionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QAxisymAdvectionDiffusionElement< NNODE_1D > >
class	FaceGeometry< QAxisymmetricLinearElasticityElement< NNODE_1D > >
	FaceGeometry of a linear QAxisymmetricLinearElasticityElement element. More...
class	FaceGeometry< QCrouzeixRaviartElement< 2 > >
	Face geometry of the 2D Crouzeix_Raviart elements. More...
class	FaceGeometry< QCrouzeixRaviartElement< 3 > >
	Face geometry of the 3D Crouzeix_Raviart elements. More...
class	FaceGeometry< QFoepplvonKarmanElement< NNODE_1D > >
	Face geometry for the QFoepplvonKarmanElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QFourierDecomposedHelmholtzElement< NNODE_1D > >
	Face geometry for the QFourierDecomposedHelmholtzElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QGeneralisedAdvectionDiffusionElement< 1, NNODE_1D > >
	Face geometry for the 1D QGeneralisedAdvectionDiffusion elements: Point elements. More...
class	FaceGeometry< QGeneralisedAdvectionDiffusionElement< DIM, NNODE_1D > >
	Face geometry for the QGeneralisedAdvectionDiffusionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QGeneralisedAxisymAdvectionDiffusionElement< NNODE_1D > >
	Face geometry for the QGeneralisedAxisymAdvectionDiffusionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QHelmholtzElement< 1, NNODE_1D > >
	Face geometry for the 1D QHelmholtzElement elements: Point elements. More...
class	FaceGeometry< QHelmholtzElement< DIM, NNODE_1D > >
	Face geometry for the QHelmholtzElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QLinearElasticityElement< 2, 2 > >
	FaceGeometry of a linear 2D QLinearElasticityElement element. More...
class	FaceGeometry< QLinearElasticityElement< 2, 3 > >
	FaceGeometry of a quadratic 2D QLinearElasticityElement element. More...
class	FaceGeometry< QLinearElasticityElement< 2, 4 > >
	FaceGeometry of a cubic 2D QLinearElasticityElement element. More...
class	FaceGeometry< QLinearElasticityElement< 3, 2 > >
	FaceGeometry of a linear 3D QLinearElasticityElement element. More...
class	FaceGeometry< QLinearElasticityElement< 3, 3 > >
	FaceGeometry of a quadratic 3D QLinearElasticityElement element. More...
class	FaceGeometry< QLinearElasticityElement< 3, 4 > >
	FaceGeometry of a cubic 3D QLinearElasticityElement element. More...
class	FaceGeometry< QLinearWaveElement< 1, NNODE_1D > >
	Face geometry for the 1D QLinearWaveElement elements: Point elements. More...
class	FaceGeometry< QLinearWaveElement< DIM, NNODE_1D > >
	Face geometry for the QLinearWaveElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QPMLFourierDecomposedHelmholtzElement< NNODE_1D > >
	Face geometry for the QPMLFourierDecomposedHelmholtzElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QPMLHelmholtzElement< 1, NNODE_1D > >
	Face geometry for the 1D QPMLHelmholtzElement elements: Point elements. More...
class	FaceGeometry< QPMLHelmholtzElement< DIM, NNODE_1D > >
	Face geometry for the QPMLHelmholtzElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QPMLTimeHarmonicLinearElasticityElement< 2, 2 > >
	FaceGeometry of a linear 2D QPMLTimeHarmonicLinearElasticityElement element. More...
class	FaceGeometry< QPMLTimeHarmonicLinearElasticityElement< 2, 3 > >
	FaceGeometry of a quadratic 2D QPMLTimeHarmonicLinearElasticityElement element. More...
class	FaceGeometry< QPMLTimeHarmonicLinearElasticityElement< 2, 4 > >
	FaceGeometry of a cubic 2D QPMLTimeHarmonicLinearElasticityElement element. More...
class	FaceGeometry< QPMLTimeHarmonicLinearElasticityElement< 3, 2 > >
	FaceGeometry of a linear 3D QPMLTimeHarmonicLinearElasticityElement element. More...
class	FaceGeometry< QPMLTimeHarmonicLinearElasticityElement< 3, 3 > >
	FaceGeometry of a quadratic 3D QPMLTimeHarmonicLinearElasticityElement element. More...
class	FaceGeometry< QPMLTimeHarmonicLinearElasticityElement< 3, 4 > >
	FaceGeometry of a cubic 3D QPMLTimeHarmonicLinearElasticityElement element. More...
class	FaceGeometry< QPoissonElement< 1, NNODE_1D > >
	Face geometry for the 1D QPoissonElement elements: Point elements. More...
class	FaceGeometry< QPoissonElement< DIM, NNODE_1D > >
	Face geometry for the QPoissonElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QPVDElement< 2, NNODE_1D > >
	FaceGeometry of a 2D QPVDElement element. More...
class	FaceGeometry< QPVDElement< 3, NNODE_1D > >
	FaceGeometry of a 3D QPVDElement element. More...
class	FaceGeometry< QPVDElementWithContinuousPressure< 2 > >
	FaceGeometry for 2D QPVDElementWithContinuousPressure element. More...
class	FaceGeometry< QPVDElementWithContinuousPressure< 3 > >
	FaceGeometry for 3D QPVDElementWithContinuousPressure element. More...
class	FaceGeometry< QPVDElementWithPressure< 2 > >
	FaceGeometry of 2D QPVDElementWithPressure. More...
class	FaceGeometry< QPVDElementWithPressure< 3 > >
	FaceGeometry of 3D QPVDElementWithPressure. More...
class	FaceGeometry< QScalarAdvectionElement< DIM, NNODE_1D > >
	Face geometry for the QScalarAdvectionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QSpectralEulerElement< DIM, NNODE_1D > >
	Face geometry for the QEulerElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QSpectralPoissonElement< 1, NNODE_1D > >
	Face geometry for the 1D QPoissonElement elements: Point elements. More...
class	FaceGeometry< QSpectralPoissonElement< DIM, NNODE_1D > >
	Face geometry for the QSpectralPoissonElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QSpectralScalarAdvectionElement< DIM, NNODE_1D > >
	Face geometry for the QScalarAdvectionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QSphericalAdvectionDiffusionElement< NNODE_1D > >
class	FaceGeometry< QSphericalCrouzeixRaviartElement >
	Face geometry of the Spherical Crouzeix_Raviart elements. More...
class	FaceGeometry< QSphericalTaylorHoodElement >
	Face geometry of the Spherical Taylor_Hood elements. More...
class	FaceGeometry< QSteadyAxisymAdvectionDiffusionElement< NNODE_1D > >
class	FaceGeometry< QTaylorHoodElement< 2 > >
	Face geometry of the 2D Taylor_Hood elements. More...
class	FaceGeometry< QTaylorHoodElement< 3 > >
	Face geometry of the 3D Taylor_Hood elements. More...
class	FaceGeometry< QTaylorHoodMixedOrderSpaceTimeElement< 2 > >
	Face geometry of the 2D Taylor_Hood elements. More...
class	FaceGeometry< QTimeHarmonicFourierDecomposedLinearElasticityElement< NNODE_1D > >
	FaceGeometry of a linear QTimeHarmonicFourierDecomposedLinearElasticityElement element. More...
class	FaceGeometry< QTimeHarmonicLinearElasticityElement< 2, 2 > >
	FaceGeometry of a linear 2D QTimeHarmonicLinearElasticityElement element. More...
class	FaceGeometry< QTimeHarmonicLinearElasticityElement< 2, 3 > >
	FaceGeometry of a quadratic 2D QTimeHarmonicLinearElasticityElement element. More...
class	FaceGeometry< QTimeHarmonicLinearElasticityElement< 2, 4 > >
	FaceGeometry of a cubic 2D QTimeHarmonicLinearElasticityElement element. More...
class	FaceGeometry< QTimeHarmonicLinearElasticityElement< 3, 2 > >
	FaceGeometry of a linear 3D QTimeHarmonicLinearElasticityElement element. More...
class	FaceGeometry< QTimeHarmonicLinearElasticityElement< 3, 3 > >
	FaceGeometry of a quadratic 3D QTimeHarmonicLinearElasticityElement element. More...
class	FaceGeometry< QTimeHarmonicLinearElasticityElement< 3, 4 > >
	FaceGeometry of a cubic 3D QTimeHarmonicLinearElasticityElement element. More...
class	FaceGeometry< QUnsteadyHeatElement< 1, NNODE_1D > >
	Face geometry for the 1D QUnsteadyHeatElement elements: Point elements. More...
class	FaceGeometry< QUnsteadyHeatElement< DIM, NNODE_1D > >
	Face geometry for the QUnsteadyHeatElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QUnsteadyHeatMixedOrderSpaceTimeElement< 1, NNODE_1D > >
	Face geometry for the 1D QUnsteadyHeatMixedOrderSpaceTimeElement elements: Point elements. More...
class	FaceGeometry< QUnsteadyHeatMixedOrderSpaceTimeElement< SPATIAL_DIM, NNODE_1D > >
	Face geometry for the QUnsteadyHeatMixedOrderSpaceTimeElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QUnsteadyHeatSpaceTimeElement< 1, NNODE_1D > >
	Face geometry for the 1D QUnsteadyHeatSpaceTimeElement elements: Point elements. More...
class	FaceGeometry< QUnsteadyHeatSpaceTimeElement< SPATIAL_DIM, NNODE_1D > >
	Face geometry for the QUnsteadyHeatSpaceTimeElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QWomersleyElement< 1, NNODE_1D > >
	Face geometry for the 1D QWomersleyElement elements: Point elements. More...
class	FaceGeometry< QWomersleyElement< DIM, NNODE_1D > >
	Face geometry for the QWomersleyElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< QYoungLaplaceElement< NNODE_1D > >
	Face geometry for the QYoungLaplaceElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableAxisymmetricQCrouzeixRaviartElement >
	Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
class	FaceGeometry< RefineableAxisymmetricQTaylorHoodElement >
	Face geometry of the RefineableQuadQTaylorHoodElements. More...
class	FaceGeometry< RefineableGeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement >
	Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
class	FaceGeometry< RefineableGeneralisedNewtonianAxisymmetricQTaylorHoodElement >
	Face geometry of the RefineableQuadQTaylorHoodElements. More...
class	FaceGeometry< RefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM > >
	Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
class	FaceGeometry< RefineableGeneralisedNewtonianQTaylorHoodElement< DIM > >
	Face geometry of the RefineableQTaylorHoodElements is the same as the Face geometry of the QTaylorHoodElements. More...
class	FaceGeometry< RefineableLinearisedAxisymmetricQCrouzeixRaviartElement >
	Face geometry of the refineable linearised axisym Crouzeix-Raviart elements. More...
class	FaceGeometry< RefineableLinearisedAxisymmetricQTaylorHoodElement >
	Face geometry of the refineable linearised axisym Taylor-Hood elements. More...
class	FaceGeometry< RefineableLinearisedQCrouzeixRaviartElement >
	Face geometry of the refineable linearised axisym Crouzeix-Raviart elements. More...
class	FaceGeometry< RefineableLinearisedQTaylorHoodElement >
	Face geometry of the refineable linearised axisym Taylor-Hood elements. More...
class	FaceGeometry< RefineablePolarCrouzeixRaviartElement >
	Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
class	FaceGeometry< RefineablePolarTaylorHoodElement >
	Face geometry of the RefineablePolarTaylorHoodElements is the same as the Face geometry of the PolarTaylorHoodElements. More...
class	FaceGeometry< RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID > >
	Explicit definition of the face geometry of these elements. More...
class	FaceGeometry< RefineableQAdvectionDiffusionElement< DIM, NNODE_1D > >
	Face geometry for the RefineableQuadAdvectionDiffusionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQAdvectionDiffusionReactionElement< NREAGENT, DIM, NNODE_1D > >
	Face geometry for the RefineableQuadAdvectionDiffusionReactionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQAxisymAdvectionDiffusionElement< NNODE_1D > >
	Face geometry for the RefineableQAxisymAdvectionDiffusionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQCrouzeixRaviartElement< DIM > >
	Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
class	FaceGeometry< RefineableQGeneralisedAdvectionDiffusionElement< DIM, NNODE_1D > >
	Face geometry for the RefineableQuadGeneralisedAdvectionDiffusionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQGeneralisedAxisymAdvectionDiffusionElement< NNODE_1D > >
	Face geometry for the RefineableQuadGeneralisedAxisymAdvectionDiffusionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQHelmholtzElement< DIM, NNODE_1D > >
	Face geometry for the RefineableQuadHelmholtzElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQLinearElasticityElement< 2, NNODE_1D > >
	FaceGeometry of the 2D RefineableQLinearElasticityElement elements. More...
class	FaceGeometry< RefineableQLinearElasticityElement< 3, NNODE_1D > >
	FaceGeometry of the 3D RefineableQLinearElasticityElement elements. More...
class	FaceGeometry< RefineableQLinearWaveElement< DIM, NNODE_1D > >
	Face geometry for the RefineableQuadLinearWaveElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQPMLHelmholtzElement< DIM, NNODE_1D > >
	Face geometry for the RefineableQuadPMLHelmholtzElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQPoissonElement< DIM, NNODE_1D > >
	Face geometry for the RefineableQuadPoissonElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQPVDElement< 2, NNODE_1D > >
	FaceGeometry of the 2D RefineableQPVDElement elements. More...
class	FaceGeometry< RefineableQPVDElement< 3, NNODE_1D > >
	FaceGeometry of the 3D RefineableQPVDElement elements. More...
class	FaceGeometry< RefineableQPVDElementWithContinuousPressure< 2 > >
	FaceGeometry of the 2D RefineableQPVDElementWithContinuousPressure elements. More...
class	FaceGeometry< RefineableQPVDElementWithContinuousPressure< 3 > >
	FaceGeometry of the 3D RefineableQPVDElementWithContinuousPressure. More...
class	FaceGeometry< RefineableQPVDElementWithPressure< 2 > >
	FaceGeometry of the 2D RefineableQPVDElementWithPressure. More...
class	FaceGeometry< RefineableQPVDElementWithPressure< 3 > >
	FaceGeometry of the 3D RefineableQPVDElementWithPressure. More...
class	FaceGeometry< RefineableQSpectralPoissonElement< DIM, NNODE_1D > >
	Face geometry for the RefineableQuadPoissonElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQSphericalAdvectionDiffusionElement< NNODE_1D > >
	Face geometry for the RefineableQSphericalAdvectionDiffusionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQSphericalCrouzeixRaviartElement >
	Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
class	FaceGeometry< RefineableQSphericalTaylorHoodElement >
	Face geometry of the RefineableQuadQTaylorHoodElements. More...
class	FaceGeometry< RefineableQTaylorHoodElement< DIM > >
	Face geometry of the RefineableQTaylorHoodElements is the same as the Face geometry of the QTaylorHoodElements. More...
class	FaceGeometry< RefineableQTaylorHoodMixedOrderSpaceTimeElement< DIM > >
	Face geometry of the class: RefineableQTaylorHoodMixedOrderSpaceTimeElements is the same as the Face geometry of: QTaylorHoodMixedOrderSpaceTimeElements. More...
class	FaceGeometry< RefineableQTimeHarmonicLinearElasticityElement< 2, NNODE_1D > >
	FaceGeometry of the 2D RefineableQTimeHarmonicLinearElasticityElement elements. More...
class	FaceGeometry< RefineableQTimeHarmonicLinearElasticityElement< 3, NNODE_1D > >
	FaceGeometry of the 3D RefineableQTimeHarmonicLinearElasticityElement elements. More...
class	FaceGeometry< RefineableQUnsteadyHeatElement< DIM, NNODE_1D > >
	Face geometry for the RefineableQuadUnsteadyHeatElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQUnsteadyHeatMixedOrderSpaceTimeElement< SPATIAL_DIM, NNODE_1D > >
	Face geometry for the RefineableQuadUnsteadyHeatMixedOrderSpaceTimeElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQUnsteadyHeatSpaceTimeElement< SPATIAL_DIM, NNODE_1D > >
	Face geometry for the RefineableQuadUnsteadyHeatSpaceTimeElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< RefineableQYoungLaplaceElement< NNODE_1D > >
	Face geometry for the RefineableQuadYoungLaplaceElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< SolidTBubbleEnrichedElement< 2, NNODE_1D > >
	Face geometry for the 2D SolidTBubbleEnrichedElement elements is exactly the same as for the corresponding 2D SolidTElement. The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< SolidTBubbleEnrichedElement< 3, NNODE_1D > >
	Face geometry for the 3D SolidTBubbleEnrichedElement elements is the 2D SolidTBubbleEnrichedElement. The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< SolidTElement< 1, NNODE_1D > >
	Face geometry for the 1D TElement elements: Point elements. More...
class	FaceGeometry< SolidTElement< DIM, NNODE_1D > >
	Face geometry for the TElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< SpineElement< ELEMENT > >
	Explicit definition of the face geometry for spine elements: The same as the face geometry of the underlying element. More...
class	FaceGeometry< SpineElement< FaceGeometry< ELEMENT > > >
	Explicit definition of the face geometry for spine elements: The same as the face geometry of the underlying element. More...
class	FaceGeometry< TAdvectionDiffusionReactionElement< NREAGENT, 1, NNODE_1D > >
	Face geometry for the 1D TAdvectionDiffusionReactionElement elements: Point elements. More...
class	FaceGeometry< TAdvectionDiffusionReactionElement< NREAGENT, DIM, NNODE_1D > >
	Face geometry for the TAdvectionDiffusionReactionElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TAxisymmetricLinearElasticityElement< NNODE_1D > >
	Face geometry for the TAxisymmetricLinearElasticityElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TAxisymmetricPoroelasticityElement< 0 > >
	Face geometry for TAxisymmetricPoroelasticityElement<0> More...
class	FaceGeometry< TAxisymmetricPoroelasticityElement< 1 > >
	Face geometry for TAxisymmetricPoroelasticityElement<1> More...
class	FaceGeometry< TBubbleEnrichedElement< 2, NNODE_1D > >
	Face geometry for the 2D TBubbleEnrichedElement elements is exactly the same as for the corresponding TElement. The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TBubbleEnrichedElement< 3, NNODE_1D > >
	Face geometry for the 3D TBubbleEnrichedElement elements is the 2D TBubbleEnrichedElement. The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TCrouzeixRaviartElement< 2 > >
	Face geometry of the 2D Crouzeix_Raviart elements. More...
class	FaceGeometry< TCrouzeixRaviartElement< 3 > >
	Face geometry of the 3D Crouzeix_Raviart elements. More...
class	FaceGeometry< TDisplacementBasedFoepplvonKarmanElement< NNODE_1D > >
	Face geometry for the TDisplacementBasedFoepplvonKarmanElement. More...
class	FaceGeometry< TElement< 1, NNODE_1D > >
	Face geometry for the 1D TElement elements: Point elements. More...
class	FaceGeometry< TElement< DIM, NNODE_1D > >
	Face geometry for the TElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TFoepplvonKarmanElement< NNODE_1D > >
	Face geometry for the TFoepplvonKarmanElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TFourierDecomposedHelmholtzElement< NNODE_1D > >
	Face geometry for the TFourierDecomposedHelmholtzElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< THelmholtzElement< 1, NNODE_1D > >
	Face geometry for the 1D THelmholtzElement elements: Point elements. More...
class	FaceGeometry< THelmholtzElement< DIM, NNODE_1D > >
	Face geometry for the THelmholtzElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TLinearElasticityElement< 1, NNODE_1D > >
	Face geometry for the 1D TLinearElasticityElement elements: Point elements. More...
class	FaceGeometry< TLinearElasticityElement< DIM, NNODE_1D > >
	Face geometry for the TLinearElasticityElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TPMLFourierDecomposedHelmholtzElement< NNODE_1D > >
	Face geometry for the TPMLFourierDecomposedHelmholtzElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TPMLHelmholtzElement< 1, NNODE_1D > >
	Face geometry for the 1D TPMLHelmholtzElement elements: Point elements. More...
class	FaceGeometry< TPMLHelmholtzElement< DIM, NNODE_1D > >
	Face geometry for the TPMLHelmholtzElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TPMLTimeHarmonicLinearElasticityElement< 1, NNODE_1D > >
	Face geometry for the 1D TPMLTimeHarmonicLinearElasticityElement elements: Point elements. More...
class	FaceGeometry< TPMLTimeHarmonicLinearElasticityElement< DIM, NNODE_1D > >
	Face geometry for the TPMLTimeHarmonicLinearElasticityElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TPoissonElement< 1, NNODE_1D > >
	Face geometry for the 1D TPoissonElement elements: Point elements. More...
class	FaceGeometry< TPoissonElement< DIM, NNODE_1D > >
	Face geometry for the TPoissonElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TPoroelasticityElement< 0 > >
	Face geometry for TPoroelasticityElement<0> More...
class	FaceGeometry< TPoroelasticityElement< 1 > >
	Face geometry for TPoroelasticityElement<1> More...
class	FaceGeometry< TPVDBubbleEnrichedElement< 2, NNODE_1D > >
	FaceGeometry of a 2D TPVDBubbleEnrichedElement element. More...
class	FaceGeometry< TPVDBubbleEnrichedElement< 3, NNODE_1D > >
	FaceGeometry of a 3D TPVDBubbleEnrichedElement element. More...
class	FaceGeometry< TPVDElement< 2, NNODE_1D > >
	FaceGeometry of a 2D TPVDElement element. More...
class	FaceGeometry< TPVDElement< 3, NNODE_1D > >
	FaceGeometry of a 3D TPVDElement element. More...
class	FaceGeometry< TPVDElementWithContinuousPressure< 2 > >
	Face geometry of the 2D Taylor_Hood elements. More...
class	FaceGeometry< TPVDElementWithContinuousPressure< 3 > >
	Face geometry of the 3D Taylor_Hood elements. More...
class	FaceGeometry< TRaviartThomasDarcyElement< 0 > >
	Face geometry for TRaviartThomasDarcyElement<0> More...
class	FaceGeometry< TRaviartThomasDarcyElement< 1 > >
	Face geometry for TRaviartThomasDarcyElement<1> More...
class	FaceGeometry< TTaylorHoodElement< 2 > >
	Face geometry of the 2D Taylor_Hood elements. More...
class	FaceGeometry< TTaylorHoodElement< 3 > >
	Face geometry of the 3D Taylor_Hood elements. More...
class	FaceGeometry< TTimeHarmonicFourierDecomposedLinearElasticityElement< NNODE_1D > >
	FaceGeometry of a linear TTimeHarmonicFourierDecomposedLinearElasticityElement element. More...
class	FaceGeometry< TTimeHarmonicLinearElasticityElement< 1, NNODE_1D > >
	Face geometry for the 1D TTimeHarmonicLinearElasticityElement elements: Point elements. More...
class	FaceGeometry< TTimeHarmonicLinearElasticityElement< DIM, NNODE_1D > >
	Face geometry for the TTimeHarmonicLinearElasticityElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TUnsteadyHeatElement< 1, NNODE_1D > >
	Face geometry for the 1D TUnsteadyHeatElement elements: Point elements. More...
class	FaceGeometry< TUnsteadyHeatElement< DIM, NNODE_1D > >
	Face geometry for the TUnsteadyHeatElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FaceGeometry< TWomersleyElement< 1, NNODE_1D > >
	Face geometry for the 1D TWomersleyElement elements: Point elements. More...
class	FaceGeometry< TWomersleyElement< DIM, NNODE_1D > >
	Face geometry for the TWomersleyElement elements: The spatial dimension of the face elements is one lower than that of the bulk element but they have the same number of points along their 1D edges. More...
class	FD_LU
	Dense LU decomposition-based solve of linear system assembled via finite differencing of the residuals Vector. Even more inefficient than DenseLU but excellent sanity check! More...
class	FiniteElement
	A general Finite Element class. More...
class	FishDomain
	Fish shaped domain, represented by four MacroElements. Shape is parametrised by GeomObject that represents the fish's back. More...
class	FishMesh
	Fish shaped mesh. The geometry is defined by the Domain object FishDomain. More...
class	FluidInterfaceAdditionalValues
	This policy class is used to allow additional values to be added to the nodes from new surface equations, for examples of usage see the SurfactantTransportFluidInterfaceElements. The use of this class avoids issues with calling virtual functions in constructors and avoids having a global look-up able, although it functions in much the same way. Typically, this will only be filled in by "expert users" and is only required if you want to write generic surface-element classes. Specific classes can always be overloaded on a case-by-case basis. More...
class	FluidInterfaceAdditionalValues< FluidInterfaceElement >
	Specific policy class for the FluidInterfaceElemetnts, which do not require any additional values at the nodes. More...
class	FluidInterfaceAdditionalValues< SurfactantTransportInterfaceElement >
	============================================================================= This is the policy class for the surfactanttransport equations which require one additional value for the surface concentration More...
class	FluidInterfaceBoundingElement
	Base class for elements at the boundary of free surfaces or interfaces, used typically to impose contact angle boundary conditions. The elemental dimensions are one less than those of the surface elements, or two less than those of the original bulk elements. Thus in two-dimensional and axi-symmetric problems, are points, but in three-dimensional problems, they are lines. These boundaries may be in contact with a solid surface, in which case the normal to that surface must be provided. More...
class	FluidInterfaceElement
	Base class establishing common interfaces and functions for all Navier-Stokes-like fluid interface elements. Namely, elements that represent either a free surface or an interface between two fluids that have distinct momentum-like equation for each velocity component. More...
class	FluxTransportEquations
	Base class for the flux transport equations templated by the dimension DIM. The equations that are solved are. More...
class	FoepplvonKarmanEquations
	A class for all isoparametric elements that solve the Foeppl von Karman equations. More...
class	FoepplvonKarmanVolumeConstraintElement
	A class which allows the user to specify a prescribed volume (as opposed to a prescribed pressure) for in the region bounded by the membrane. Effectively adds an equation to the system for pressure. There would usually only be a single instance of this element in a problem. More...
class	FoldHandler
	A class that is used to assemble the augmented system that defines a fold (saddle-node) or limit point. The "standard" problem must be a function of a global paramter , and a solution is , where are the unknowns in the problem. A limit point is formally specified by the augmented system of size . More...
class	FourierDecomposedHelmholtzBCElementBase
	A class for elements that allow the approximation of the Sommerfeld radiation BC for Fourier decomposed Helmholtz equations. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	FourierDecomposedHelmholtzDtNBoundaryElement
	FaceElement used to apply Sommerfeld radiation conditon via Dirichlet to Neumann map. More...
class	FourierDecomposedHelmholtzDtNMesh
	================================================================= Mesh for DtN boundary condition elements – provides functionality to apply Sommerfeld radiation condtion More...
class	FourierDecomposedHelmholtzEquations
	A class for all isoparametric elements that solve the Helmholtz equations. More...
class	FourierDecomposedHelmholtzFluxElement
	A class for elements that allow the imposition of an applied flux on the boundaries of Fourier decomposed Helmholtz elements. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	FourierDecomposedHelmholtzFluxFromNormalDisplacementBCElement
	A class for elements that allow the imposition of an prescribed flux (determined from the normal displacements of an adjacent linearly elastic solid. Normal derivative for displacement potential is given by normal displacement of adjacent solid multiplies by FSI parameter (q = k^2 B/E). The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	FourierDecomposedTimeHarmonicLinElastLoadedByHelmholtzPressureBCElement
	A class for elements that allow the imposition of an applied traction in the equations of time-harmonic linear elasticity from a Helmholtz potential (interpreted as a displacement potential for the fluid in a quasi-steady, linearised FSI problem.) The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	FpPreconditionerAssemblyHandler
	A class that is used to define the functions used to assemble the elemental contributions to the pressure advection diffusion problem used by the Fp preconditioner. More...
class	FpPressureAdvDiffRobinBCElement
	A class for elements that allow the imposition of Robin boundary conditions for the pressure advection diffusion problem in the Fp preconditioner. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	FpPressureAdvDiffRobinBCElementBase
	Helper class for elements that impose Robin boundary conditions on pressure advection diffusion problem required by Fp preconditioner (class used to get around some templating issues) More...
class	FpPressureAdvDiffRobinBCMixedOrderSpaceTimeElement
	A class for elements that allow the imposition of Robin boundary conditions for the pressure advection diffusion problem in the Fp preconditioner. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	FpPressureAdvDiffRobinBCMixedOrderSpaceTimeElementBase
	Helper class for elements that impose Robin boundary conditions on pressure advection diffusion problem required by Fp preconditioner (class used to get around some templating issues) More...
class	FpPressureAdvectionDiffusionProblem
	Auxiliary Problem that can be used to assemble the pressure advection diffusion matrix needed by the FpPreconditoner. More...
class	FreeStandingFaceElement
	Basic-ified FaceElement, without any of the functionality of of actual FaceElements – it's just a surface element of the same geometric type as the FaceGeometry associated with bulk element specified by the template parameter. The element can be used to represent boundaries without actually being attached to a bulk element. Used mainly during unstructured mesh generation. More...
class	FSIAxisymFoepplvonKarmanElement
	FSI Axisym FoepplvonKarmanElement elements are 1D Foeppl von Karman elements with isoparametric interpolation for the function. Gets traction from adjacent fluid element(s) of type FLUID_ELEMENT. More...
class	FSIAxisymmetricLinearElasticityTractionElement
	A class for elements that allow the imposition of an applied traction in the equations of axisymmetric linear elasticity from an adjacent axisymmetric Navier Stokes element in a linearised FSI problem. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	FSIAxisymmetricQTaylorHoodElement
	Axisymmetric FSI Element. More...
class	FSIDiagHermiteShellElement
	Diag Hermite Kirchhoff Love shell "upgraded" to a FSIWallElement (and thus, by inheritance, a GeomObject), so it can be used in FSI. More...
class	FSIDrivenCavityMesh
	Mesh for W. Wall's FSI driven cavity problem. The mesh is derived from the SimpleRectangularQuadMesh so it's node and element numbering scheme is the same as in that mesh. Only the boundaries are numbered differently to allow the easy identification of the "collapsible" segment. Boundary coordinates are set up for all nodes located on boundary 3 (the collapsible segment). The curvilinear ("collapsible") segment is defined by a GeomObject. More...
class	FSIFluidElement
	The FSIFluidElement class is a base class for all fluid finite elements that apply a load (traction) onto an adjacent SolidFiniteElement. More...
class	FSIHermiteBeamElement
	Hermite Kirchhoff Love beam "upgraded" to a FSIWallElement (and thus, by inheritance, a GeomObject), so it can be used in FSI. More...
class	FSIImposeDisplacementByLagrangeMultiplierElement
	A class for elements that allow the imposition of a displacement constraint for bulk solid elements via a Lagrange multiplier. Prescribed displaced is obtained from an adjacent bulk solid element (rather than from a lower-dimensional GeomObject as in the corresponding ImposeDisplacementByLagrangeMultiplierElement class. The present class is particularly suited for parallel FSI computations. NOTE: Currently (and for the foreseeable future) this element only works with bulk elements that do not have generalised degrees of freedom (so it won't work with Hermite-type elements, say). The additional functionality to deal with such elements could easily be added (once a a suitable test case is written). For now we simply throw errors if an attempt is made to use the element with an unsuitable bulk element. More...
class	FSILinearisedAxisymPoroelasticTractionElement
	A class for elements that allow the imposition of an applied combined traction and pore fluid pressure in the poroelasticity equations. The geometrical information can be read from the FaceGeometry<ELEMENT> class and thus, we can be generic enough without the need to have a separate equations class. More...
class	FSIPreconditioner
	FSI preconditioner. This extracts upper/lower triangular blocks in the 3x3 overall block matrix structure arising from the monolithic discretisation of FSI problems with algebraic node updates. Dofs are decomposed into fluid velocity, pressure and solid unknowns. NavierStokesSchurComplementPreconditioner is used as the inexact solver for the fluid block; SuperLU (in its incarnation as an "exact" preconditioner) is used for the solid block. By default we retain the fluid on solid off diagonal blocks. More...
class	FSISolidTractionElement
	SolidTractionElement "upgraded" to a FSIWallElement (and thus, by inheritance, a GeomObject), so it can be used in FSI. The element is templated by the bulk solid element and the spatial (Eulerian) dimension of the bulk element. More...
class	FSIWallElement
	This is a base class for all SolidFiniteElements that participate in FSI computations. These elements provide interfaces and generic funcionality for the two additional roles that SolidFiniteElements play in FSI problems: More...
class	FullCircleDomain
	Topologically circular domain, e.g. a tube cross section. The entire domain must be defined by a GeomObject with the following convention: zeta[0] is the radial coordinate and zeta[1] is the theta coordinate around the cross-sectin. The outer boundary must lie at zeta[0] = 1. More...
class	FullCircleMesh
	Full circle mesh class. The domain is specified by the GeomObject that identifies the entire area. Non-refineable base version! More...
class	Gauss
	Class for multidimensional Gaussian integration rules. More...
class	Gauss< 1, 2 >
	1D Gaussian integration class. Two integration points. This integration scheme can integrate up to third-order polynomials exactly and is therefore a suitable "full" integration scheme for linear (two-node) elements in which the highest-order polynomial is quadratic. More...
class	Gauss< 1, 3 >
	1D Gaussian integration class. Three integration points. This integration scheme can integrate up to fifth-order polynomials exactly and is therefore a suitable "full" integration scheme for quadratic (three-node) elements in which the highest-order polynomial is fourth order. More...
class	Gauss< 1, 4 >
	1D Gaussian integration class Four integration points. This integration scheme can integrate up to seventh-order polynomials exactly and is therefore a suitable "full" integration scheme for cubic (four-node) elements in which the highest-order polynomial is sixth order. More...
class	Gauss< 2, 2 >
	2D Gaussian integration class. 2x2 integration points. This integration scheme can integrate up to third-order polynomials exactly and is therefore a suitable "full" integration scheme for linear (four-node) elements in which the highest-order polynomial is quadratic. More...
class	Gauss< 2, 3 >
	2D Gaussian integration class. 3x3 integration points. This integration scheme can integrate up to fifth-order polynomials exactly and is therefore a suitable "full" integration scheme for quadratic (nine-node) elements in which the highest-order polynomial is fourth order. More...
class	Gauss< 2, 4 >
	2D Gaussian integration class. 4x4 integration points. This integration scheme can integrate up to seventh-order polynomials exactly and is therefore a suitable "full" integration scheme for cubic (sixteen-node) elements in which the highest-order polynomial is sixth order. More...
class	Gauss< 3, 2 >
	3D Gaussian integration class 2x2x2 integration points. This integration scheme can integrate up to third-order polynomials exactly and is therefore a suitable "full" integration scheme for linear (eight-node) elements in which the highest-order polynomial is quadratic. More...
class	Gauss< 3, 3 >
	3D Gaussian integration class 3x3x3 integration points. This integration scheme can integrate up to fifth-order polynomials exactly and is therefore a suitable "full" integration scheme for quadratic (27-node) elements in which the highest-order polynomial is fourth order. More...
class	Gauss< 3, 4 >
	3D Gaussian integration class. 4x4x4 integration points. This integration scheme can integrate up to seventh-order polynomials exactly and is therefore a suitable "full" integration scheme for cubic (64-node) elements in which the highest-order polynomial is sixth order. More...
class	Gauss< 3, 5 >
	3D Dummy Gaussian integration class, so that we can make a <3,5> brick for meshing More...
class	Gauss_Rescaled
	Class for multidimensional Gaussian integration rules, over intervals other than -1 to 1, all intervals are rescaled in this case. More...
class	GaussLegendre
	Class for multidimensional Gauss Legendre integration rules empty - just establishes template parameters. More...
class	GaussLegendre< 1, NPTS_1D >
	1D Gauss Legendre integration class More...
class	GaussLegendre< 2, NPTS_1D >
	2D Gauss Legendre integration class More...
class	GaussLegendre< 3, NPTS_1D >
	3D Gauss Legendre integration class More...
class	GaussLobattoLegendre
	Class for multidimensional Gauss Lobatto Legendre integration rules empty - just establishes template parameters. More...
class	GaussLobattoLegendre< 1, NPTS_1D >
	1D Gauss Lobatto Legendre integration class More...
class	GaussLobattoLegendre< 2, NPTS_1D >
	2D Gauss Lobatto Legendre integration class More...
class	GaussLobattoLegendre< 3, NPTS_1D >
	3D Gauss Lobatto Legendre integration class More...
class	GeneralElasticityTensor
	A general elasticity tensor that provides storage for all 21 independent components. More...
class	GeneralisedAdvectionDiffusionEquations
	A class for all elements that solve the Advection Diffusion equations in conservative form using isoparametric elements. More...
class	GeneralisedAxisymAdvectionDiffusionEquations
class	GeneralisedElement
	A Generalised Element class. More...
class	GeneralisedHookean
	Class for a "non-rational" extension of classical linear elasticity to large displacements: More...
class	GeneralisedMooneyRivlin
	Generalisation of Mooney Rivlin constitutive law to compressible media as suggested on p. 553 of Fung, Y.C. & Tong, P. "Classical and Computational Solid Mechanics" World Scientific (2001). Input parameters are Young's modulus E, Poisson ratio nu and the Mooney-Rivlin constant C1. In the small-deformation-limit the behaviour becomes equivalent to that of linear elasticity with the same E and nu. More...
class	GeneralisedNewtonianAxisymmetricNavierStokesEquations
	A class for elements that solve the unsteady axisymmetric Navier–Stokes equations in cylindrical polar coordinates, and with . We're solving for the radial, axial and azimuthal (swirl) velocities, and , respectively, and the pressure . This class contains the generic maths – any concrete implementation must be derived from this. More...
class	GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement
	Crouzeix_Raviart elements are Navier–Stokes elements with quadratic interpolation for velocities and positions, but a discontinuous linear pressure interpolation. More...
class	GeneralisedNewtonianAxisymmetricQTaylorHoodElement
	Taylor–Hood elements are Navier–Stokes elements with quadratic interpolation for velocities and positions and continous linear pressure interpolation. More...
class	GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement
	GeneralisedNewtonianAxisymmetricTCrouzeix_Raviart elements are. More...
class	GeneralisedNewtonianAxisymmetricTTaylorHoodElement
	Taylor–Hood elements are Navier–Stokes elements with quadratic interpolation for velocities and positions and continous linear pressure interpolation. More...
class	GeneralisedNewtonianConstitutiveEquation
	A Base class defining the generalise Newtonian constitutive relation. More...
class	GeneralisedNewtonianNavierStokesEquations
	A class for elements that solve the cartesian Navier–Stokes equations, templated by the dimension DIM. This contains the generic maths – any concrete implementation must be derived from this. More...
class	GeneralisedNewtonianProjectableAxisymmetricCrouzeixRaviartElement
	Crouzeix Raviart upgraded to become projectable. More...
class	GeneralisedNewtonianProjectableAxisymmetricTaylorHoodElement
	GeneralisedNewtonianAxisymmetric Taylor Hood upgraded to become projectable. More...
class	GeneralisedNewtonianQCrouzeixRaviartElement
	Crouzeix_Raviart elements are Navier–Stokes elements with quadratic interpolation for velocities and positions, but a discontinuous linear pressure interpolation. They can be used within oomph-lib's block preconditioning framework. More...
class	GeneralisedNewtonianQTaylorHoodElement
	Taylor–Hood elements are Navier–Stokes elements with quadratic interpolation for velocities and positions and continuous linear pressure interpolation. They can be used within oomph-lib's block-preconditioning framework. More...
class	GeneralisedNewtonianTCrouzeixRaviartElement
	TCrouzeix_Raviart elements are Navier–Stokes elements with quadratic interpolation for velocities and positions enriched by a single cubic bubble function, but a discontinuous linear pressure interpolation. More...
class	GeneralisedNewtonianTemplateFreeNavierStokesEquationsBase
	Template-free base class for Navier-Stokes equations to avoid casting problems. More...
class	GeneralisedNewtonianTTaylorHoodElement
	Taylor–Hood elements are Navier–Stokes elements with quadratic interpolation for velocities and positions and continous linear pressure interpolation. More...
class	GeneralisedTimeStepper
	Generalised timestepper that can serve a variety of purposes in continuation, bifurcation detection and periodic-orbit computations. The key generalisation is that more than one of the entries is actually a degree of freedom in the problem. These are distinct from our standard (implict) Timesteppers in which the only dof is the current value (first entry in the storage scheme). These objects will typically be used to replace exisiting timesteppers for specific tasks. More...
class	GeneralPurposeBlockPreconditioner
	Base class for general purpose block preconditioners. Deals with setting subsidiary preconditioners and dof to block maps. Subsidiary preconditioners can be set in two ways: 1) A pointer to a subsidiary preconditioner for block i can be passed to set_subsidiary_preconditioner_pt(prec, i). 2) A default subsidiary preconditioner can be set up by providing a function pointer to a function which creates a preconditioner. During setup() all unset subsidiary preconditioner pointers will be filled in using this function. By default this uses SuperLU. More...
class	GenericLagrangeInterpolatedProjectableElement
	Class that makes the finite element specified as template argument projectable – on the assumption that all fields are interpolated by isoparametric Lagrange interpolation between the nodes. More...
class	GeomObject
	A geometric object is an object that provides a parametrised description of its shape via the function GeomObject::position(...). More...
class	GeompackQuadMesh
	Quadrilateral mesh generator; Uses input from Geompack++. See: http://members.shaw.ca/bjoe/ Currently only for four-noded quads – extension to higher-order quads should be trivial (see the corresponding classes for triangular meshes). More...
class	GeompackQuadScaffoldMesh
	Mesh that is based on input files generated by the quadrilateral mesh generator Geompack. More...
class	GMRES
	The GMRES method. More...
class	GMRESBlockPreconditioner
	The block preconditioner form of GMRES. This version extracts the blocks from the global systems and assembles the system by concatenating all the matrices together. More...
class	GmshParameters
	Class to collate parameters for Gmsh mesh generation. More...
class	GmshTetMesh
	Forward declaration. More...
class	GmshTetScaffoldMesh
class	GS
	The Gauss Seidel method. More...
class	GS< CRDoubleMatrix >
	Explicit template specialisation of the Gauss Seidel method for compressed row format matrices. More...
class	GZipReader
class	HangInfo
	Class that contains data for hanging nodes. More...
class	HeightControlElement
	Height control element for YoungLaplace equations: Prescribe displacement along a spine (i.e. the "height of the meniscus" in exchange for treating the curvature as an unknown. Very similar to the DisplacementControlElement used in solid mechanics problems. More...
class	HelmholtzAbsorbingBCElement
	Absorbing BC element for approximation imposition of Sommerfeld radiation condition. More...
class	HelmholtzBCElementBase
	A class for elements that allow the approximation of the Sommerfeld radiation BC. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	HelmholtzDtNBoundaryElement
	FaceElement used to apply Sommerfeld radiation conditon via Dirichlet to Neumann map. More...
class	HelmholtzDtNMesh
	================================================================= Mesh for DtN boundary condition elements – provides functionality to apply Sommerfeld radiation condtion More...
class	HelmholtzEquations
	A class for all isoparametric elements that solve the Helmholtz equations. More...
class	HelmholtzFGMRESMG
	The FGMRES method, i.e. the flexible variant of the GMRES method which allows for nonconstant preconditioners [see Saad Y, "Iterative methods for sparse linear systems", p.287]. Note, FGMRES can only cater to right preconditioning; if the user tries to switch to left preconditioning they will be notified of this. More...
class	HelmholtzFluxElement
	A class for elements that allow the imposition of an applied flux on the boundaries of Helmholtz elements. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	HelmholtzFluxFromNormalDisplacementBCElement
	A class for elements that allow the imposition of an prescribed flux (determined from the normal displacements of an adjacent linearly elastic solid. Normal derivative for displacement potential is given by normal displacement of adjacent solid multiplies by FSI parameter (q = k^2 B/E). The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	HelmholtzGMRESMG
	The GMRES method for the Helmholtz solver. More...
class	HelmholtzMGPreconditioner
class	HelmholtzMGProblem
	HelmholtzMGProblem class; subclass of Problem. More...
class	HelmholtzSmoother
	Helmholtz smoother class: The smoother class is designed for the Helmholtz equation to be used in conjunction with multigrid. The action of the smoother should reduce the high frequency errors. These methods are inefficient as stand-alone solvers. More...
class	HermiteBeamElement
	Hermite Kirchhoff Love beam. Implements KirchhoffLoveBeamEquations using 2-node Hermite elements as the underlying geometrical elements. More...
class	HermitePVDElement
	An Element that solves the principle of virtual diplacements using Hermite interpolation for the variable positions. More...
class	HermiteQuadMesh
	A two dimensional Hermite bicubic element quadrilateral mesh for a topologically rectangular domain. The geometry of the problem must be prescribed using the TopologicallyRectangularDomain. Non uniform node spacing can be prescribed using a function pointer. More...
class	HermiteShellElement
	An element that solves the Kirchhoff-Love shell theory equations using Hermite interpolation (displacements and slopes are interpolated separately. The local and global (Lagrangian) coordinates are not assumed to be aligned. N.B. It will be DOG SLOW. More...
class	HerschelBulkleyBerEngRegConstitutiveEquation
	A GeneralisedNewtonianConstitutiveEquation class defining a Herschel-Bulkley fluid using Bercovier and Engelman's (1980) regularisation. More...
class	HerschelBulkleyMenDutRegConstitutiveEquation
	A GeneralisedNewtonianConstitutiveEquation class defining a Herschel-Bulkley fluid using Mendes and Dutra's (2004) regularisation. More...
class	HerschelBulkleyPapRegConstitutiveEquation
	A GeneralisedNewtonianConstitutiveEquation class defining a Herschel-Bulkley fluid using Papanastasiou's (1987) regularisation. More...
class	HerschelBulkleyTanMilRegConstitutiveEquation
	A GeneralisedNewtonianConstitutiveEquation class defining a Herschel-Bulkley fluid using Tanner and Milthorpe's (1983) regularisation. More...
class	HerschelBulkleyTanMilRegWithBlendingConstitutiveEquation
	A GeneralisedNewtonianConstitutiveEquation class defining a Herschel-Bulkley fluid using Tanner and Milthorpe's (1983) regularisation with a smooth transition using a quadratic. More...
class	Hijacked
	Hijacked elements are elements in which one or more Data values that affect the element's residuals, are determined by another element – the data values are then said to have been hijacked by another element. The main functionality added by the Hijacked element class is that it wipes out those entries in the element's residual vector and those rows in the element's Jacobian matrix that are determined by the "other" elements that have hijacked the values. Note that for continuation in homotopy parameters, it may be desriable to multiply the residuals and corresponding jacobian entries by a "homotopy parameter". The value of this parameter can be set by assigning residual_multiplier_pt() which has a default value of zero. Note: it would be possible to extend the functionality so that different residuals are multiplied by different values, but will this ever be required? More...
class	HijackedData
	Custom Data class that is used when HijackingData. The class always contains a single value that is copied from another Data object. More...
class	HijackedElementBase
	HijackedElement base class that provides storage and access funcitons for pointers to the global equation numbers that are hijacked by the HijackedElement. A default residuals multiplier is also provided. More...
class	HopfHandler
	A class that is used to assemble the augmented system that defines a Hopf bifurcation. The "standard" problem must be a function of a global parameter and a solution is , where are the unknowns in the problem. A Hopf bifurcation may be specified by the augmented system of size . More...
class	HorizontalSingleLayerSpineMesh
	Horizontal Single-layer spine mesh class derived from standard 2D mesh. The mesh contains a layer of spinified fluid elements (of type ELEMENT; e.g SpineElement<QCrouzeixRaviartElement<2>) and the information required to update their position. Additional equations must be specified in order to determine how the spines move. More...
class	HSL_MA42
	Linear solver class that provides a wrapper to the frontal solver MA42 from the HSL library; see http://www.hsl.rl.ac.uk/. More...
class	HypreInterface
	An interface class to the suite of Hypre solvers and preconditioners to allow use of: More...
class	HyprePreconditioner
	An Preconditioner class using the suite of Hypre preconditioners to allow. More...
class	HypreSolver
	An LinearSolver class using the suite of Hypre solvers to allow. More...
class	IdentityPreconditioner
	The Identity Preconditioner. More...
class	ILUZeroPreconditioner
	ILU(0) Preconditioner. More...
class	ILUZeroPreconditioner< CCDoubleMatrix >
	ILU(0) Preconditioner for matrices of CCDoubleMatrix Format. More...
class	ILUZeroPreconditioner< CRDoubleMatrix >
	ILU(0) Preconditioner for matrices of CRDoubleMatrix Format. More...
class	ImmersedRigidBodyElement
	Class that solves the equations of motion for a general two-dimensional rigid body subject to a particular imposed force and torque distribution and immersed within an external fluid. The body's position is entirely specified by the location of its centre of mass, , and a single angle, , that represents a possible rotation. The equations of motion are then simply Newton's second law for the conservation of linear momentum in two directions and angular momentum about the single possible axis of rotation. More...
class	ImmersedRigidBodyTriangleMeshPolygon
	Class upgrading a TriangleMeshPolygon to a "hole" for use during triangle mesh generation. For mesh generation purposes, the main (and only) addition to the base class is the provision of the coordinates of a hole inside the polygon. To faciliate the movement of the "hole" through the domain we also provide a Data object whose three values represent the x and y displacements of its centre of gravity and the polygon's rotation about its centre of gravity. If added to a mesh in the Problem (in its incarnation as a GeneralisedElement) the displacement/rotation of the polygon is computed in response to (i) user-specifiable applied forces and a torque and (ii) the net drag (and associated torque) from a mesh of elements that can exert a drag onto the polygon (typically Navier-Stokes FaceElements that apply a viscous drag to an immersed body, represented by the polygon.) More...
class	ImposeDisplacementByLagrangeMultiplierElement
	A class for elements that allow the imposition of a displacement constraint for "bulk" solid elements via a Lagrange multiplier. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. NOTE: Currently (and for the foreseeable future) this element only works with bulk elements that do not have generalised degrees of freedom (so it won't work with Hermite-type elements, say). The additional functionality to deal with such elements could easily be added (once a a suitable test case is written). For now we simply throw errors if an attempt is made to use the element with an unsuitable bulk element. More...
class	ImposeFluxForWomersleyElement
	Element to impose volume flux through collection of Womersley elements, in exchange for treating the pressure gradient as an unknown. The pressure gradient is created (as a single-valued Data item) in the constructor for this element which also takes a pointer to the Mesh containing the Womersley elements whose total flux is being controlled. While doing this we tell them that their pressure gradient is now an unknown and must be treated as external Data. More...
class	ImposeImpenetrabilityElement
	ImposeImpenetrabilityElement are elements that coincide with the faces of higher-dimensional "bulk" elements. They are used on boundaries where we would like to impose impenetrability. More...
class	ImposeParallelOutflowElement
	ImposeParallelOutflowElement are elements that coincide with the faces of higher-dimensional "bulk" elements. They are used on boundaries where we would like to impose parallel outflow and impose the pressure. More...
class	IMR
	The "real" implementation of the implicit midpoint rule. Implemented by calculation of residuals etc. at half step. This requires non-trivial modifications to the element's residual and Jacobian calculation functions to interpolate values to the midpoint. As such IMRByBDF should be preferred. More...
class	IMRBase
	Implicit midpoint rule base class for the two implementations. More...
class	IMRByBDF
	Implementation of implicit midpoint rule by taking half a step of bdf1 then applying an update to all dofs. This implementation should work with any existing problem for which the BDF methods work. More...
class	InexactSubBiharmonicPreconditioner
	SubBiharmonic Preconditioner - an inexact preconditioner for the 3x3 top left hand corner sub block matrix. Used as part of the BiharmonicPreconditioner<MATRIX> More...
class	InnerIterationPreconditioner
	A preconditioner for performing inner iteration preconditioner solves. The template argument SOLVER specifies the inner iteration solver (which must be derived from IterativeLinearSolver) and the template argument PRECONDITIONER specifies the preconditioner for the inner iteration iterative solver. Note: For no preconditioning use the IdentityPreconditioner. More...
class	Integral
	Generic class for numerical integration schemes: More...
class	InvertedElementError
	A class to specify when the error is caused by an inverted element. More...
class	IsotropicElasticityTensor
	An isotropic elasticity tensor defined in terms of Young's modulus and Poisson's ratio. The elasticity tensor is assumed to be non-dimensionalised on some reference value for Young's modulus so the value provided to the constructor (if any) is to be interpreted as the ratio of the actual Young's modulus to the Young's modulus used to non-dimensionalise the stresses/tractions in the governing equations. More...
class	IsotropicStrainEnergyFunctionConstitutiveLaw
	A class for constitutive laws derived from strain-energy functions. Theory is in Green and Zerna. More...
class	IterativeLinearSolver
	Base class for all linear iterative solvers. This merely defines standard interfaces for linear iterative solvers, so that different solvers can be used in a clean and transparent manner. More...
class	KirchhoffLoveBeamEquations
	A class for elements that solve the equations of Kirchhoff-Love large-displacement (but linearly-elastic) thin-beam theory. More...
class	KirchhoffLoveShellEquations
	A class for elements that solves the equations of Kirchhoff Love shell thin-shell theory. More...
class	LagrangeEnforcedFlowPreconditioner
	The preconditioner for the Lagrange multiplier constrained Navier-Stokes equations. The velocity components are constrained by Lagrange multiplier, which are applied via OOMPH-LIB's FACE elements. More...
class	LAPACK_QZ
	Class for the LAPACK QZ eigensolver. More...
class	LinearAlgebraDistribution
	Describes the distribution of a distributable linear algebra type object. Typically this is a container (such as a DoubleVector) or an operator (e.g Preconditioner or LinearSolver). This object is used in both serial and parallel implementations. In the serial context (no MPI) this just contains an integer indicating the number of rows. In parallel either each processor holds a subset of the set of global rows. (each processor contains only a single continuous block of rows - parametised with variables denoting the first row and the number of local rows) or, all rows are be duplicated across all processors. In parallel this object also contains an OomphCommunicator object which primarily contains the MPI_Comm communicator associated with this object. More...
class	LinearElasticityEquations
	A class for elements that solve the equations of linear elasticity in cartesian coordinates. More...
class	LinearElasticityEquationsBase
	A base class for elements that solve the equations of linear elasticity in Cartesian coordinates. Combines a few generic functions that are shared by LinearElasticityEquations and LinearElasticityEquationsWithPressure (hierher: The latter don't exist yet but will be written as soon as somebody needs them...) More...
class	LinearElasticitySmoothMesh
	Auxiliary Problem to smooth a SolidMesh by adjusting the internal nodal positions by solving a LINEAR solid mechanics problem for the nodal displacements between the specified displacements of certain pinned nodes (usually located on boundaries). The template parameter specifies the linear elasticity element that must have the same shape (geometric element type) as the elements contained in the mesh that's to be smoothed. So, e.g. for the ten-noded three-dimensional tetrahedral TTaylorHoodElement<3>, it would be a TLinearElasticityElement<3,3>, etc. Important assumptions: More...
class	LinearElasticityTractionElement
	A class for elements that allow the imposition of an applied traction in the equations of linear elasticity. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	LinearisedAxisymmetricNavierStokesEquations
	A class for elements that solve the linearised version of the unsteady Navier–Stokes equations in cylindrical polar coordinates, where we have Fourier-decomposed in the azimuthal direction so that the theta-dependance is replaced by an azimuthal mode number. More...
class	LinearisedAxisymmetricQCrouzeixRaviartElement
	Crouzeix-Raviart elements are Navier-Stokes elements with quadratic interpolation for velocities and positions, but a discontinuous linear pressure interpolation. More...
class	LinearisedAxisymmetricQTaylorHoodElement
	Taylor–Hood elements are Navier–Stokes elements with quadratic interpolation for velocities and positions and continuous linear pressure interpolation. More...
class	LinearisedAxisymPoroelasticBJS_FSIElement
	A class for elements that allow the imposition of the linearised poroelastic FSI slip condition (according to the Beavers-Joseph-Saffman condition) from an adjacent poroelastic axisymmetric medium. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	LinearisedFSIAxisymmetricNStNoSlipBCElementElement
	A class for elements that allow the imposition of the linearised FSI no slip condition from an adjacent linearly elastic axisymmetric solid. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	LinearisedNavierStokesEigenfunctionNormalisationElement
	A class that is used to implement the constraint that the eigenfunction has a particular normalisation. This element stores the two components of the eigenvalue. More...
class	LinearisedNavierStokesEquations
	A class for elements that solve the linearised version of the unsteady Navier–Stokes equations in cylindrical polar coordinates, where we have Fourier-decomposed in the azimuthal direction so that the theta-dependance is replaced by an azimuthal mode number. More...
class	LinearisedQCrouzeixRaviartElement
	Crouzeix-Raviart elements are Navier-Stokes elements with quadratic interpolation for velocities and positions, but a discontinuous linear pressure interpolation. More...
class	LinearisedQTaylorHoodElement
	Taylor–Hood elements are Navier–Stokes elements with quadratic interpolation for velocities and positions and continuous linear pressure interpolation. More...
class	LinearSolver
	Base class for all linear solvers. This merely defines standard interfaces for linear solvers, so that different solvers can be used in a clean and transparent manner. Note that LinearSolvers are primarily used to solve the linear systems arising in oomph-lib's Newton iteration. Their primary solve function therefore takes a pointer to the associated problem, construct its Jacobian matrix and residual vector, and return the solution of the linear system formed by the Jacobian and the residual vector. We also provide broken virtual interfaces to a linear-algebra-type solve function in which the matrix and the rhs can be specified, but this are not guaranteed to implemented for all linear solvers (e.g. for frontal solvers). More...
class	LinearWaveEquations
	A class for all isoparametric elements that solve the LinearWave equations. More...
class	LinearWaveFluxElement
	A class for elements that allow the imposition of an applied flux on the boundaries of LinearWave elements. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	LineDerivatives
	Class that establishes the surface derivative functions for LineElements. These are defined in a separate class so that they can be used by other interface equation-type classes. More...
class	LineElementBase
	Base class for all line elements. More...
class	LineFluidInterfaceBoundingElement
	Specialisation of the interface boundary constraint to a line. More...
class	LineMeshBase
	Base class for line meshes (meshes made of 1D line elements) More...
class	LineVisualiser
	Class to aid visualisation of the values on a set of points. NOTE: in a distributed problem, output is only done on processor 0. More...
class	LineVolumeConstraintBoundingElement
	One-dimensional interface elements that allow the application of a volume constraint on the region bounded by these elements. The volume is computed by integrating x.n around the boundary of the domain and then dividing by two. The sign is chosen so that the volume will be positive when the elements surround a fluid domain. More...
class	LowStorageRungeKutta
	=========================================================== Runge Kutta Timestepping that uses low storage More...
class	MacroElement
	Base class for MacroElement s that are used during mesh refinement in domains with curvlinear and/or time-dependent boundaries; see the description of the Domain class for more details. More...
class	MacroElementNodeUpdateChannelWithLeafletMesh
	Channel with leaflet mesh with MacroElement-based node update. The leaflet is represented by the specified geometric object. Some or all of the geometric Data in that geometric object may contain unknowns in the global Problem. The dependency on these unknowns is taken into account when setting up the Jacobian matrix of the elements. For this purpose, the element (whose type is specified by the template parameter) must inherit from MacroElementNodeUpdateElementBase. More...
class	MacroElementNodeUpdateCollapsibleChannelMesh
	Collapsible channel mesh with MacroElement-based node update. The collapsible segment is represented by the specified geometric object. Some or all of the geometric Data in that geometric object may contain unknowns in the global Problem. The dependency on these unknowns is taken into account when setting up the Jacobian matrix of the elements. For this purpose, the element (whose type is specified by the template parameter) must inherit from MacroElementNodeUpdateElementBase. More...
class	MacroElementNodeUpdateElement
	MacroElementNodeUpdate elements are elements that can not only be updated via their MacroElement representation (in princple any FiniteElement could do that...) but also allows the geometric Data contained in the GeomObjects that affect the MacroElement-based node update operations to be unknowns in the overall Problem. More...
class	MacroElementNodeUpdateElementBase
	Base class for elements that allow MacroElement-based node update. More...
class	MacroElementNodeUpdateMesh
	MacroElementNodeUpdateMeshes contain MacroElementNodeUpdateNodes which have their own node update functions. When the node's node_update() function is called, they also perform any auxiliary update functions, e.g. to update no-slip boundary conditions on moving domain boundaries. More...
class	MacroElementNodeUpdateNode
	MacroElementNodeUpdate nodes are nodes with a positional update function, based on their element's MacroElement representation. More...
class	MacroElementNodeUpdateRefineableChannelWithLeafletMesh
	Refineable mesh with MacroElement-based node update. More...
class	MacroElementNodeUpdateRefineableCollapsibleChannelMesh
	Refineable collapsible channel mesh with MacroElement-based node update. The collapsible segment is represented by the specified geometric object. Some or all of the geometric Data in that geometric object may contain unknowns in the global Problem. The dependency on these unknowns is taken into account when setting up the Jacobian matrix of the elements. For this purpose, the element (whose type is specified by the template parameter) must inherit from MacroElementNodeUpdateElementBase. More...
class	MacroElementNodeUpdateRefineableFishMesh
	Refineable fish shaped mesh with MacroElement-based node update. The fish's back is represented by a specified geometric object. Some or all of the geometric Data in that geometric object may contain unknowns in the global Problem. The dependency on these unknowns is taken into account when setting up the Jacobian matrix of the elements. For this purpose, the element (whose type is specified by the template parameter) must inherit from MacroElementNodeUpdateElementBase. More...
class	MacroElementNodeUpdateRefineableQuarterCircleSectorMesh
	MacroElementNodeUpdate version of RefineableQuarterCircleSectorMesh. More...
class	MacroElementNodeUpdateRefineableQuarterTubeMesh
	MacroElementNodeUpdate version of RefineableQuarterTubeMesh. More...
class	MapMatrix
	MapMatrix is a generalised, STL-map-based, sparse(-ish) matrix class. More...
class	MapMatrixMixed
	MapMatrixMixed is a generalised, STL-map-based, sparse(ish) matrix class with mixed indices. More...
class	Matrix
	Abstract base class for matrices, templated by the type of object that is stored in them and the type of matrix. The MATRIX_TYPE template argument is used as part of the Curiously Recurring Template Pattern, see http://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern The pattern is used to force the inlining of the round bracket access functions by ensuring that they are NOT virtual functions. More...
class	MatrixBasedDiagPreconditioner
	Matrix-based diagonal preconditioner. More...
class	MatrixBasedLumpedPreconditioner
	Matrix-based lumped preconditioner. More...
class	MatrixVectorProduct
	Matrix vector product helper class - primarily a wrapper to Trilinos's Epetra matrix vector product methods. This allows the epetra matrix to be assembled once and the matrix vector product to be performed many times. More...
class	Mesh
	A general mesh class. More...
class	MeshAsGeomObject
	This class provides a GeomObject representation of a given finite element mesh. The Lagrangian coordinate is taken to be the dimension of the (first) element in the mesh and the Eulerian coordinate is taken to be the dimension of the (first) node in the mesh. If there are no elements or nodes the appropriate dimensions will be set to zero. The constituent elements of the mesh must have their own GeomObject representations, so they must be FiniteElements, and they become sub-objects in this compound GeomObject. More...
class	MGPreconditioner
	An interface to allow scalar MG to be used as a Preconditioner. More...
class	MGProblem
	MGProblem class; subclass of Problem. More...
class	MGSolver
class	MinModLimiter
class	MooneyRivlin
	MooneyRivlin strain-energy function. with constitutive parameters C1 and C2: More...
class	MPI_Helpers
	MPI_Helpers class contains static helper methods to support MPI within oomph-lib. The methods init(...) and finalize() initialize and finalize MPI in oomph-lib and manage the oomph-libs global communicator communicator_pt(). NOTE: This class encapsulates static helper methods and instances of it CANNOT be instantiated. More...
class	MPIOutputModifier
	MPI output modifier: Precedes every output by specification of the processor ID. Output can be restricted to a single processor. More...
class	MumpsPreconditioner
	An interface to allow Mumps to be used as an (exact) Preconditioner. More...
class	MumpsSolver
	Wrapper to Mumps solver. More...
class	NavierStokesBoussinesqElement
	Build NavierStokesBoussinesqElement that inherits from ElementWithExternalElement so that it can "communicate" with AdvectionDiffusionElementWithExternalElement. More...
class	NavierStokesElementWithDiagonalMassMatrices
	Pure virtual base class for elements that can be used with Navier-Stokes Schur complement preconditioner and provide the diagonal of their velocity and pressure mass matrices – needs to be defined here (in generic) because this applies to a variety of Navier-Stokes elements (cartesian, cylindrical polar, ...) that can be preconditioned effectively by the Navier Stokes (!) preconditioners in the (cartesian) Navier-Stokes directory. More...
class	NavierStokesEquations
	A class for elements that solve the cartesian Navier–Stokes equations, templated by the dimension DIM. This contains the generic maths – any concrete implementation must be derived from this. More...
class	NavierStokesExactPreconditioner
	The exact Navier Stokes preconditioner. This extracts 2x2 blocks (corresponding to the velocity and pressure unknowns) and uses these to build a single preconditioner matrix for testing purposes. Iterative solvers should converge in a single step if this is used. If it doesn't something is wrong in the setup of the block matrices. More...
class	NavierStokesFluxControlElement
	A class of element to impose an applied boundary pressure to Navier-Stokes elements to control to control a volume flux. A mesh of these elements are used in conjunction with a NetFluxControlElement. The template arguement ELEMENT is a Navier-Stokes "bulk" element. More...
class	NavierStokesImpedanceTractionElement
	A class for elements that allow the imposition of an impedance type traction boundary condition to the Navier–Stokes equations The geometrical information can be read from the FaceGeometery<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. Template arguments specify the type of the bulk Navier Stokes elements that the elements are attached to, and the type of the Womersley element used to compute the flow resistance in the downstream "impedance tube". More...
class	NavierStokesImpedanceTractionElementBase
	A base class for elements that allow the imposition of an impedance type boundary condition to the Navier–Stokes equations. Establishes the template-free common functionality, that they must have to be able to compute the volume flux that passes through them, etc. More...
class	NavierStokesMixedOrderSpaceTimeTractionElement
	A class for elements that allow the imposition of an applied traction to the Navier–Stokes equations The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	NavierStokesSchurComplementPreconditioner
	The least-squares commutator (LSC; formerly BFBT) Navier Stokes preconditioner. It uses blocks corresponding to the velocity and pressure unknowns, i.e. there are a total of 2x2 blocks, and all velocity components are treated as a single block of unknowns. More...
class	NavierStokesSurfaceDragTorqueElement
	A class of elements that allow the determination of the drag and toque, relative to a given centre of rotation, along a domain boundary. The element operates as a FaceElement and attaches itself to a bulk element of the type specified by the template argument. More...
class	NavierStokesSurfacePowerElement
	A class of elements that allow the determination of the power input and various other fluxes over the domain boundaries. The element operates as a FaceElement and attaches itself to a bulk element of the type specified by the template argument. More...
class	NavierStokesTractionElement
	A class for elements that allow the imposition of an applied traction to the Navier–Stokes equations The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	NavierStokesWomersleyPressureControlElement
	An element to impose a fluid pressure obtained from a Womersley impedance tube at a boundary. This element is used in conjunction with a NetFluxControlElementForWomersleyPressureControl element, and is passed to the NetFluxControlElementForWomersleyPressureControl element's constructor. The volume flux across the boundary is then an unknown of the problem. The constructor argument for this element is a suitable Womersley impedance tube to give the pressure via its get_response(...) function. More...
class	NetFluxControlElement
	A class for an element that controls the net fluid flux across a boundary by the imposition of an unknown applied pressure to the Navier-Stokes equations. This element is used with a mesh of NavierStokesFluxControlElement elements which are attached to the boundary. Note: fill_in_contribution_to_jacobian() does not calculate Jacobian contributions for this element as they are calculated by NavierStokesFluxControlElement::fill_in_contribution_to_jacobian(...) More...
class	NetFluxControlElementForWomersleyPressureControl
	A class for an element to control net fluid flux across a boundary by imposing an applied pressure to the Navier-Stokes equations. This element is used with a mesh of NavierStokesFluxControlElements attached to the boundary. The flux imposed by this element is given by a NavierStokesWomersleyPressureControlElement. Note: fill_in_contribution_to_jacobian() does not calculate any Jacobian contributions for this element as they are calculated by NavierStokesFluxControlElement::fill_in_contribution_to_jacobian(...) and NavierStokesWomersleyPressureControlElement:: fill_in_contribution_to_jacobian(...) More...
class	Newmark
	Newmark scheme for second time deriv. Stored data represents. More...
class	NewmarkBDF
	Newmark scheme for second time deriv with first derivatives calculated using BDF. . Stored data represents. More...
class	NewtonianConstitutiveEquation
	A GeneralisedNewtonianConstitutiveEquation class defining a Newtonian fluid. More...
class	NewtonSolverError
	A class to handle errors in the Newton solver. More...
class	NicosConstitutiveEquation
	A GeneralisedNewtonianConstitutiveEquation class defining an arbitrary shear-thinning fluid. More...
class	Node
	Nodes are derived from Data, but, in addition, have a definite (Eulerian) position in a space of a given dimension. More...
class	NonLinearElasticitySmoothMesh
	Auxiliary Problem to smooth a SolidMesh by adjusting the internal nodal positions via the solution of a nonlinear solid mechanics problem. The mesh will typically have been created with an unstructured mesh generator that uses a low-order (simplex) representation of the element geometry; some of the nodes, typically non-vertex nodes on the domain's curvilinear boundaries, were then moved to their new position to provide a more accurate representation of the geometry. This class should be used to deal with elements that may have become inverted during the node motion. Important assumption: More...
class	NonRefineableBinArrayParameters
	Helper object for dealing with the parameters used for the NonRefineableBinArray objects. More...
class	NonRefineableElementWithHangingNodes
	A base class for elements that can have hanging nodes but are not refineable as such. This class is usually used as a base class for FaceElements that are attached to refineable bulk elements (and stripped out before adapting the bulk mesh, so they don't participate in the refimenent process itself). We therefore simply break the pure virtual functions that don't make any sense for such elements. More...
class	NonRefineableSolidElementWithHangingNodes
	A base class for SolidElements that can have hanging nodes but are not refineable as such. This class is usually used as a base class for FaceElements that are attached to refineable bulk elements (and stripped out before adapting the bulk mesh, so they don't participate in the refimenent process itself). We therefore simply break the pure virtual functions that don't make any sense for such elements. More...
class	Nullstream
	A small nullstream class that throws away everything sent to it. More...
class	OcTree
	OcTree class: Recursively defined, generalised octree. More...
class	OcTreeForest
	An OcTreeForest consists of a collection of OcTreeRoots. Each member tree can have neighbours to its L/R/U/D/F/B and DB/UP/... and the orientation of their compasses can differ, allowing for complex, unstructured meshes. More...
class	OcTreeRoot
	OcTreeRoot is a OcTree that forms the root of a (recursive) octree. The "root node" is special as it holds additional information about its neighbours and their relative rotation (inside a OcTreeForest). More...
class	ODEElement
	Element for integrating an initial value ODE. More...
class	OneDimensionalLegendreDShape
class	OneDimensionalLegendreShape
	Class that returns the shape functions associated with legendre. More...
class	OneDimensionalModalDShape
class	OneDimensionalModalShape
	Non-templated class that returns modal hierachical shape functions based on Legendre polynomials. More...
class	OneDLagrangianMesh
	1D mesh parametrised in terms of a 1D Lagrangian coordinate. The Eulerian positions of the nodes are determined by the GeomObject. More...
class	OneDLegendreDShapeParam
class	OneDLegendreShapeParam
	Class that returns the shape functions associated with legendre. More...
class	OneDMesh
	1D mesh consisting of N one-dimensional elements from the QElement family. More...
class	OomphCommunicator
	An oomph-lib wrapper to the MPI_Comm communicator object. Just contains an MPI_Comm object (which is a pointer) and wrappers to the MPI_... methods. More...
class	OomphInfo
	This class is a wrapper to a stream and an output modifier that is used to control the "info" output from OomphLib. Its instationiation can be used like std::cout. More...
class	OomphLibError
	An OomphLibError object which should be thrown when an run-time error is encountered. The error stream and stream width can be specified. The default is cerr with a width of 70 characters. More...
class	OomphLibException
	===================================================================== A Base class for oomph-lib run-time exception (error and warning) handling. More...
class	OomphLibPreconditionerEpetraOperator
	An Epetra_Operator class for oomph-lib preconditioners. A helper class for TrilinosOomphLibPreconditioner to allow an oomph-lib preconditioner (i.e. one derived from Preconditioner) to be used with a trilinos solver (TrilinosAztecOOSolver) More...
class	OomphLibQuietException
	===================================================================== A class for handling oomph-lib run-time exceptions quietly. More...
class	OomphLibWarning
	An OomphLibWarning object which should be created as a temporary object to issue a warning. The warning stream and stream width can be specified. The default is cerr with a width of 70 characters. More...
class	OutputModifier
	A base class that contains a single virtual member function: The () operator that may be used to modify the output in. More...
struct	Packet
class	ParallelResidualsHandler
	A class that is used to assemble the residuals in parallel by overloading the get_all_vectors_and_matrices, so that only the residuals are returned. This ensures that the (moderately complex) distributed parallel assembly loops are only in one place. More...
class	ParameterDerivativeHandler
	A class that is used to define the functions used when assembling the derivatives of the residuals with respect to a parameter. The idea is to replace get_residuals with get_dresiduals_dparameter with a particular parameter and assembly handler that are passed on assembly. More...
class	PeriodicOrbitAssemblyHandler
	A class that is used to assemble and solve the augmented system of equations associated with calculating periodic orbits directly. More...
class	PeriodicOrbitAssemblyHandlerBase
	=============================================================== Base class to avoid template complications More...
class	PeriodicOrbitBaseElement
class	PeriodicOrbitEquations
class	PeriodicOrbitTemporalMesh
	A special temporal mesh class. More...
class	PeriodicOrbitTimeDiscretisation
	Timestepper used to calculate periodic orbits directly. It's not really a "timestepper" per se, but represents the time storage and means of calculating time-derivatives given the underlying discretisation. More...
class	PicardConvergenceData
	Object that collates convergence data of Picard iteration. More...
class	PitchForkHandler
	A class that is used to assemble the augmented system that defines a pitchfork (symmetry-breaking) bifurcation. The "standard" problem must be a function of a global parameter and a solution is , where are the unknowns in the problem. A pitchfork bifurcation may be specified by the augmented system of size . More...
class	PMLCornerQuadMesh
	PML mesh, derived from RectangularQuadMesh. More...
class	PMLElementBase
	Base class for elements with pml capabilities. More...
class	PMLFourierDecomposedHelmholtzEquations
	A class for all isoparametric elements that solve the Helmholtz equations with pml capabilities. in Fourier decomposed form (cylindrical polars): More...
class	PMLFourierDecomposedHelmholtzFluxElement
	A class for elements that allow the imposition of an applied flux on the boundaries of Fourier decomposed Helmholtz elements. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	PMLFourierDecomposedHelmholtzPowerMonitorElement
	A class for elements that allow postprocessing of the results – currently computes radiated power over domain boundaries. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	PMLHelmholtzEquations
	A class for all isoparametric elements that solve the Helmholtz equations with pml capabilities. This contains the generic maths. Shape functions, geometric mapping etc. must get implemented in derived class. More...
class	PMLHelmholtzFluxElement
	A class for elements that allow the imposition of an applied flux on the boundaries of PMLHelmholtz elements. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	PMLHelmholtzFluxFromNormalDisplacementBCElement
	A class for elements that allow the imposition of an prescribed flux (determined from the normal displacements of an adjacent linearly elastic solid. Normal derivative for displacement potential is given by normal displacement of adjacent solid multiplies by FSI parameter (q = k^2 B/E). The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	PMLHelmholtzPowerElement
	A class for elements that allow the post-processing of radiated power and flux on the boundaries of PMLHelmholtz elements. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	PMLLayerElement
	General definition of policy class defining the elements to be used in the actual PML layers. Has to be instantiated for each specific "bulk" PML element type. More...
class	PMLLayerElement< ProjectablePMLFourierDecomposedHelmholtzElement< TPMLFourierDecomposedHelmholtzElement< NNODE_1D > > >
	Policy class defining the elements to be used in the actual PML layers. It's the corresponding quads. More...
class	PMLLayerElement< ProjectablePMLHelmholtzElement< TPMLHelmholtzElement< 2, NNODE_1D > > >
	Policy class defining the elements to be used in the actual PML layers. It's the corresponding quads. More...
class	PMLLayerElement< ProjectablePMLTimeHarmonicLinearElasticityElement< TPMLTimeHarmonicLinearElasticityElement< 2, NNODE_1D > > >
	Policy class defining the elements to be used in the actual PML layers. Same spatial dimension and nnode_1d but quads rather than triangles. More...
class	PMLLayerElement< QPMLFourierDecomposedHelmholtzElement< NNODE_1D > >
	Policy class defining the elements to be used in the actual PML layers. Same! More...
class	PMLLayerElement< QPMLHelmholtzElement< 2, NNODE_1D > >
	Policy class defining the elements to be used in the actual PML layers. Same! More...
class	PMLLayerElement< QPMLTimeHarmonicLinearElasticityElement< 2, NNODE_1D > >
	Policy class defining the elements to be used in the actual PML layers. Same! More...
class	PMLLayerElement< RefineableQPMLHelmholtzElement< 2, NNODE_1D > >
	Policy class defining the elements to be used in the actual PML layers. Same! More...
class	PMLLayerElement< TPMLFourierDecomposedHelmholtzElement< NNODE_1D > >
	Policy class defining the elements to be used in the actual PML layers. It's the corresponding quad. More...
class	PMLLayerElement< TPMLHelmholtzElement< 2, NNODE_1D > >
	Policy class defining the elements to be used in the actual PML layers. It's the corresponding quads. More...
class	PMLLayerElement< TPMLTimeHarmonicLinearElasticityElement< 2, NNODE_1D > >
	Policy class defining the elements to be used in the actual PML layers. Same spatial dimension and nnode_1d but quads rather than triangles. More...
class	PMLMapping
	Class to hold the mapping function (gamma) for the Pml which defines how the coordinates are transformed in the Pml. This class holds the one dimensional or uniaxial case which is the most common. More...
class	PMLMappingAndTransformedCoordinate
	Class to hold the mapping function for the PML. More...
class	PMLMeshBase
	PML mesh base class. Contains a pure virtual locate_zeta function to be uploaded in PMLQuadMesh and PMLBrickMesh (once the code for it has been written) More...
class	PMLQuadMesh
	PML mesh, derived from RectangularQuadMesh. More...
class	PMLQuadMeshBase
	PML mesh class. Policy class for 2D PML meshes. More...
class	PMLTimeHarmonicElasticityTensor
	A base class that represents the fourth-rank elasticity tensor defined such that. More...
class	PMLTimeHarmonicIsotropicElasticityTensor
	An isotropic elasticity tensor defined in terms of Young's modulus and Poisson's ratio. The elasticity tensor is assumed to be non-dimensionalised on some reference value for Young's modulus so the value provided to the constructor (if any) is to be interpreted as the ratio of the actual Young's modulus to the Young's modulus used to non-dimensionalise the stresses/tractions in the governing equations. More...
class	PMLTimeHarmonicLinearElasticityEquations
	A class for elements that solve the equations of linear elasticity in cartesian coordinates. More...
class	PMLTimeHarmonicLinearElasticityEquationsBase
	A base class for elements that solve the equations of time-harmonic linear elasticity in Cartesian coordinates. Combines a few generic functions that are shared by PMLTimeHarmonicLinearElasticityEquations and PMLTimeHarmonicLinearElasticityEquationsWithPressure (Note: The latter don't exist yet but will be written as soon as somebody needs them...) More...
class	PMLTimeHarmonicLinearElasticityTractionElement
	A class for elements that allow the imposition of an applied traction in the equations of time-harmonic linear elasticity. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	PointElement
	Point element has just a single node and a single shape function which is identically equal to one. More...
class	PointFluidInterfaceBoundingElement
	Specialisation of the interface boundary constraint to a point. More...
class	PointIntegral
	Broken pseudo-integration scheme for points elements: Iit's not clear in general what this integration scheme is supposed to. It probably ought to evaluate integrals to zero but we're not sure in what context this may be used. Replace by your own integration scheme that does what you want! More...
class	PoissonEquations
	A class for all isoparametric elements that solve the Poisson equations. More...
class	PoissonFluxElement
	A class for elements that allow the imposition of an applied flux on the boundaries of Poisson elements. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	PoissonSmoothMesh
	Functor to smooth a SolidMesh by adjusting the internal nodal positions by solving a Poisson problem for the nodal displacements in the interior. The displacements of the specified pinned nodes (usually located on boundaries) remain fixed (their displacements are computed from the difference between their Lagrangian and Eulerian coordinates). The assumptions is that the Lagrangian coordinates in the SolidMesh still reflect the original nodal positions before the boundary nodes were moved. The template parameter specifies the Poisson element that must have the same shape (geometric element type) as the elements contained in the mesh that's to be smoothed. So, e.g. for the ten-noded three-dimensional tetrahedral TTaylorHoodElement<3>, it would be a TPoissonElement<3,3>, etc. More...
class	PolarCrouzeixRaviartElement
	Crouzeix_Raviart elements are Navier–Stokes elements with quadratic interpolation for velocities and positions, but a discontinuous linear pressure interpolation. More...
class	PolarNavierStokesEquations
	A class for elements that solve the polar Navier–Stokes equations, This contains the generic maths – any concrete implementation must be derived from this. More...
class	PolarNavierStokesTractionElement
	A class for elements that allow the imposition of an applied traction to the Navier–Stokes equations The geometrical information can be read from the FaceGeometery<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	PolarStressIntegralElement
	A class for elements that allow the imposition of an applied traction to the Navier–Stokes equations The geometrical information can be read from the FaceGeometery<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	PolarTaylorHoodElement
	Taylor–Hood elements are Navier–Stokes elements with quadratic interpolation for velocities and positions and continous linear pressure interpolation. More...
class	PoroelasticityEquations
	Class implementing the generic maths of the poroelasticity equations: linear elasticity coupled with Darcy equations (using Raviart-Thomas elements with both edge and internal degrees of freedom) More...
class	PoroelasticityFaceElement
	A class for elements that allow the imposition of an applied pressure in the Darcy equations. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	PowerLawBerEngRegConstitutiveEquation
	A GeneralisedNewtonianConstitutiveEquation class defining a power-law fluid regularised according to Bercovier and Engelman (1980) to allow for n < 1. More...
class	Preconditioner
	Preconditioner base class. Gives an interface to call all other preconditioners through and stores the matrix and communicator pointers. All preconditioners should be derived from this class. More...
class	PreconditionerArray
	PreconditionerArray - NOTE - first implementation, a number of assumptions / simplifications were made: More...
class	PRefineableElement
	p-refineable version of RefineableElement More...
class	PRefineableGeneralisedNewtonianQCrouzeixRaviartElement
	p-refineable version of Crouzeix Raviart elements. Generic class definitions More...
class	PRefineableQCrouzeixRaviartElement
	p-refineable version of Crouzeix Raviart elements. Generic class definitions More...
class	PRefineableQElement
	A class that is used to template the p-refineable Q elements by dimension. It's really nothing more than a policy class. The default template parameter ensures that these elements inherit from the QElement of the correct type if they start with a p-order higher than linear (e.g. Navier-Stokes Elements). More...
class	PRefineableQElement< 1, INITIAL_NNODE_1D >
	p-refineable version of RefineableQElement<1,INITIAL_NNODE_1D>. Generic class definitions More...
class	PRefineableQElement< 2, INITIAL_NNODE_1D >
	p-refineable version of RefineableQElement<2,INITIAL_NNODE_1D>. More...
class	PRefineableQElement< 3, INITIAL_NNODE_1D >
	p-refineable version of RefineableQElement<3,INITIAL_NNODE_1D>. More...
class	PRefineableQLinearElasticityElement
	p-refineable version of 2D QLinearElasticityElement elements More...
class	PRefineableQPoissonElement
	p-refineable version of 2D QPoissonElement elements More...
class	PressureBasedSolidExactPreconditioner
	The exact solid preconditioner. This extracts 2x2 blocks (corresponding to the displacement/position and pressure unknowns) and uses these to build a single preconditioner matrix for testing purposes. Iterative solvers should converge in a single step if this is used. If it doesn't something is wrong in the setup of the block matrices. More...
class	PressureBasedSolidLSCPreconditioner
	The least-squares commutator (LSC; formerly BFBT) preconditioner. It uses blocks corresponding to the displacement/position and pressure unknowns, i.e. there are a total of 2x2 blocks, and all displacement/position components are treated as a single block of unknowns. More...
class	Problem
	////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
class	ProblemBasedShiftInvertOperator
	Class for the shift invert operation. More...
class	ProjectableAdvectionDiffusionReactionElement
	AdvectionDiffusionReaction upgraded to become projectable. More...
class	ProjectableAxisymLinearElasticityElement
	Axisym linear elasticity upgraded to become projectable. More...
class	ProjectableAxisymmetricCrouzeixRaviartElement
	Crouzeix Raviart upgraded to become projectable. More...
class	ProjectableAxisymmetricPoroelasticityElement
	Axisymmetric poro elasticity upgraded to become projectable. More...
class	ProjectableAxisymmetricTaylorHoodElement
	Axisymmetric Taylor Hood upgraded to become projectable. More...
class	ProjectableCrouzeixRaviartElement
	Crouzeix Raviart upgraded to become projectable. More...
class	ProjectableDarcyElement
	Darcy upgraded to become projectable. More...
class	ProjectableDisplacementBasedFoepplvonKarmanElement
	Foeppl von Karman upgraded to become projectable. More...
class	ProjectableElement
	Wrapper class for projectable elements. Adds "projectability" to the underlying ELEMENT. More...
class	ProjectableElementBase
	Template-free Base class for projectable elements. More...
class	ProjectableFoepplvonKarmanElement
	Foeppl von Karman upgraded to become projectable. More...
class	ProjectableFourierDecomposedHelmholtzElement
	Fourier decomposed Helmholtz upgraded to become projectable. More...
class	ProjectableGeneralisedNewtonianCrouzeixRaviartElement
	Crouzeix Raviart upgraded to become projectable. More...
class	ProjectableGeneralisedNewtonianTaylorHoodElement
	Taylor Hood upgraded to become projectable. More...
class	ProjectableHelmholtzElement
	Helmholtz upgraded to become projectable. More...
class	ProjectableLinearElasticityElement
	Linear elasticity upgraded to become projectable. More...
class	ProjectablePMLFourierDecomposedHelmholtzElement
	Fourier decomposed Helmholtz upgraded to become projectable. More...
class	ProjectablePMLHelmholtzElement
	PMLHelmholtz upgraded to become projectable. More...
class	ProjectablePMLTimeHarmonicLinearElasticityElement
	Time-harmonic linear elasticity upgraded to become projectable. More...
class	ProjectablePoissonElement
	Poisson upgraded to become projectable. More...
class	ProjectablePVDElement
	PVDElementWithContinuousPressure upgraded to become projectable. More...
class	ProjectablePVDElementWithContinuousPressure
	PVDElementWithContinuousPressure upgraded to become projectable. More...
class	ProjectableTaylorHoodElement
	Taylor Hood upgraded to become projectable. More...
class	ProjectableTaylorHoodMixedOrderSpaceTimeElement
	Taylor Hood upgraded to become projectable. More...
class	ProjectableTimeHarmonicFourierDecomposedLinearElasticityElement
	Fourier-decomposed time-harmonic linear elasticity upgraded to become projectable. More...
class	ProjectableTimeHarmonicLinearElasticityElement
	Time-harmonic linear elasticity upgraded to become projectable. More...
class	ProjectableUnsteadyHeatElement
	UnsteadyHeat upgraded to become projectable. More...
class	ProjectableUnsteadyHeatMixedOrderSpaceTimeElement
	SpaceTimeUnsteadyHeatMixedOrder upgraded to become projectable. More...
class	ProjectableUnsteadyHeatSpaceTimeElement
	SpaceTimeUnsteadyHeat upgraded to become projectable. More...
class	ProjectionProblem
	Projection problem. This is created during the adaptation of unstructured meshes and it is assumed that no boundary conditions have been set. If they have, they will be unset during the projection and must be reset afterwards. More...
class	PseudoBucklingRing
	Pseudo buckling ring: Circular ring deformed by the N-th buckling mode of a thin-wall elastic ring. More...
class	PseudoBucklingRingElement
	Pseudo buckling ring: Circular ring deformed by the N-th buckling mode of a thin-wall elastic ring. More...
class	PseudoElasticChannelWithLeafletMesh
	Channel with leaflet mesh upgraded to (pseudo-)solid mesh. More...
class	PseudoElasticFSIPreconditioner
	Preconditioner for FSI problems with pseudo-elastic fluid node updates. Note: NavierStokesSchurComplementPreconditioner is applied to the Navier Stokes subsidiary system. Default solid preconditioner is ExactPreconditioner. Enumeration of Elastic DOF types in the Pseudo-Elastic Elements The method get_dof_types_for_unknowns() must be implemented such that DOFs subject be Lagrange multiplier and DOFs NOT subject to Lagrange multiplier have different labels. For example in a 3D problem there are 6 DOF types and the following labelling must be implemented: 0 - x displacement (without lagr mult traction) 1 - y displacement (without lagr mult traction) 2 - z displacement (without lagr mult traction) 3 - x displacement (with lagr mult traction) 4 - y displacement (with lagr mult traction) 5 - z displacement (with lagr mult traction) More...
class	PseudoElasticPreconditioner
	A subsidiary preconditioner for the pseudo-elastic FSI preconditioner. Also a stand-alone preconditioner for the problem of non-linear elasticity subject to prescribed displacement by Lagrange multiplier. Enumeration of Elastic DOF types in the Pseudo-Elastic Elements The method get_dof_types_for_unknowns() must be implemented such that DOFs subject be Lagrange multiplier and DOFs NOT subject to Lagrange multiplier have different labels. For example in a 3D problem there are 6 DOF types and the following labelling must be implemented: 0 - x displacement (without lagr mult traction) 1 - y displacement (without lagr mult traction) 2 - z displacement (without lagr mult traction) 4 - x displacement (with lagr mult traction) 5 - y displacement (with lagr mult traction) 6 - z displacement (with lagr mult traction) More...
class	PseudoElasticPreconditionerOld
	A subsidiary preconditioner for the pseudo-elastic FSI preconditioner. Also a stand-alone preconditioner for the problem of non-linear elasticity subject to prescribed displacement by Lagrange multiplier.. Enumeration of Elastic DOF types in the Pseudo-Elastic Elements The method get_dof_types_for_unknowns() must be implemented such that DOFs subject be Lagrange multiplier and DOFs NOT subject to Lagrange multiplier have different labels. For example in a 3D problem there are 6 DOF types and the following labelling must be implemented: 0 - x displacement (without lagr mult traction) 1 - y displacement (without lagr mult traction) 2 - z displacement (without lagr mult traction) 4 - x displacement (with lagr mult traction) 5 - y displacement (with lagr mult traction) 6 - z displacement (with lagr mult traction) More...
class	PseudoElasticPreconditionerScalingHelperOld
	A helper class for PseudoElasticPreconditioner. Note that this is NOT actually a functioning preconditioner. We simply derive from this class to get access to the blocks. More...
class	PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld
	Subsidiary helper preconditioner for the PseudoElasticPreconditioner. Required for block preconditioner of the augmented elastic subsidiary problem. NOTE: More...
class	PseudoElasticPreconditionerSubsidiaryPreconditionerOld
	Subsidiary helper preconditioner for the PseudoElasticPreconditioner. Required to construct the augmented elastic system prior to preconditioning. NOTE: More...
class	PseudoSolidNodeUpdateElement
	A templated class that permits combination two different element types, for the solution of problems in deforming domains. The first template paremter BASIC is the standard element and the second SOLID solves the equations that are used to control the mesh deformation. More...
class	PVDEquations
	A class for elements that solve the equations of solid mechanics, based on the principle of virtual displacements in cartesian coordinates. More...
class	PVDEquationsBase
	A base class for elements that solve the equations of solid mechanics, based on the principle of virtual displacements in Cartesian coordinates. Combines a few generic functions that are shared by PVDEquations and PVDEquationsWithPressure. More...
class	PVDEquationsWithPressure
	A class for elements that solve the equations of solid mechanics, based on the principle of virtual displacements, with a contitutive equation that involves a pressure. This formulation is required in the case of incompressible materials, in which the additional constraint that volume must be conserved is applied. In this case, the Incompressible flag must be set to true. If the Incompressible flag is not set to true, we use the nearly-incompressible formulation of the constitutive equations. More...
class	QAdvectionDiffusionElement
	QAdvectionDiffusionElement elements are linear/quadrilateral/brick-shaped Advection Diffusion elements with isoparametric interpolation for the function. More...
class	QAdvectionDiffusionReactionElement
	QAdvectionDiffusionReactionElement elements are linear/quadrilateral/brick-shaped Advection Diffusion elements with isoparametric interpolation for the function. More...
class	QAxisymAdvectionDiffusionElement
	QAxisymAdvectionDiffusionElement elements are linear/quadrilateral/brick-shaped Axisymmetric Advection Diffusion elements with isoparametric interpolation for the function. More...
class	QAxisymmetricLinearElasticityElement
	An Element that solves the equations of axisymmetric (in cylindrical polars) linear elasticity, using QElements for the geometry. More...
class	QCrouzeixRaviartElement
	Crouzeix_Raviart elements are Navier–Stokes elements with quadratic interpolation for velocities and positions, but a discontinuous linear pressure interpolation. They can be used within oomph-lib's block preconditioning framework. More...
class	QElement
	General QElement class. More...
class	QElement< 1, NNODE_1D >
	General QElement class specialised to one spatial dimension. More...
class	QElement< 2, NNODE_1D >
	General QElement class specialised to two spatial dimensions. More...
class	QElement< 3, NNODE_1D >
	General QElement class specialised to three spatial dimensions. More...
class	QElementBase
	Base class for Qelements. More...
class	QElementGeometricBase
	Empty base class for Qelements (created so that we can use dynamic_cast<>() to figure out if a an element is a Qelement (from a purely geometric point of view). More...
class	QExtrudedMacroElement
	QExtrudedMacroElement. More...
class	QExtrudedMacroElement< 3 >
	DRAIG: FILL IN COMPLETE DESCRIPTION ONCE FINISHED... More...
class	QFoepplvonKarmanElement
	QFoepplvonKarmanElement elements are linear/quadrilateral/brick-shaped Foeppl von Karman elements with isoparametric interpolation for the function. More...
class	QFourierDecomposedHelmholtzElement
	QFourierDecomposedHelmholtzElement elements are linear/quadrilateral/brick-shaped FourierDecomposedHelmholtz elements with isoparametric interpolation for the function. More...
class	QGeneralisedAdvectionDiffusionElement
	QGeneralisedAdvectionDiffusionElement elements are linear/quadrilateral/brick-shaped Advection Diffusion elements with isoparametric interpolation for the function. More...
class	QGeneralisedAxisymAdvectionDiffusionElement
	QGeneralisedAxisymAdvectionDiffusionElement elements are linear/quadrilateral/brick-shaped Advection Diffusion elements with isoparametric interpolation for the function. More...
class	QHelmholtzElement
	QHelmholtzElement elements are linear/quadrilateral/brick-shaped Helmholtz elements with isoparametric interpolation for the function. More...
class	QHermiteElement
	General QHermiteElement class. Local coordinates are not assumed to be aligned with the global coordinates so the Jacobian of the mapping between local and global coordinates is a full matrix. For cases where the coordinates are aligned, you should use the derived class, DiagQHermiteElement, which uses a simplified mapping that makes the evaluation of derivatives of the shape functions much cheaper. More...
class	QHermiteElementBase
	Empty base class for QHermiteElements (created so that we can use dynamic_cast<>() to figure out if a an element is a QHermiteElement). More...
class	QLinearElasticityElement
	An Element that solves the equations of linear elasticity in Cartesian coordinates, using QElements for the geometry. More...
class	QLinearWaveElement
	QLinearWaveElement elements are linear/quadrilateral/brick-shaped LinearWave elements with isoparametric interpolation for the function. More...
class	QMacroElement
	QMacroElement. More...
class	QMacroElement< 2 >
	QMacroElement specialised to 2 spatial dimensions. More...
class	QMacroElement< 3 >
	QMacroElement specialised to 3 spatial dimensions. More...
class	QPMLFourierDecomposedHelmholtzElement
	QPMLFourierDecomposedHelmholtzElement elements are linear/quadrilateral/brick-shaped PMLFourierDecomposedHelmholtz elements with isoparametric interpolation for the function. More...
class	QPMLHelmholtzElement
	QPMLHelmholtzElement elements are linear/quadrilateral/ brick-shaped PMLHelmholtz elements with isoparametric interpolation for the function. More...
class	QPMLTimeHarmonicLinearElasticityElement
	An Element that solves the equations of linear elasticity in Cartesian coordinates, using QElements for the geometry. More...
class	QPoissonElement
	QPoissonElement elements are linear/quadrilateral/brick-shaped Poisson elements with isoparametric interpolation for the function. More...
class	QPVDElement
	An Element that solves the solid mechanics equations, based on the principle of virtual displacements in Cartesian coordinates, using SolidQElements for the interpolation of the variable positions. More...
class	QPVDElementWithContinuousPressure
	An Element that solves the equations of solid mechanics, based on the discretised principle of virtual displacements, using quadratic interpolation for the positions and continuous linear solid pressure. This is analagous to the QTaylorHoodElement fluid element. More...
class	QPVDElementWithPressure
	An Element that solves the equations of solid mechanics, using the principle of virtual displacements, with quadratic interpolation for the positions and a discontinuous linear solid pressure. This is analogous to the QCrouzeixRaviartElement element for fluids. More...
class	QScalarAdvectionElement
	Non-spectral version of the classes. More...
class	QSolidElementBase
	Base class for Solid Qelements. More...
class	QSpectralElement
	General QLegendreElement class. More...
class	QSpectralElement< 1, NNODE_1D >
	General QSpectralElement class specialised to one spatial dimension. More...
class	QSpectralElement< 2, NNODE_1D >
	General QSpectralElement class specialised to two spatial dimensions. More...
class	QSpectralElement< 3, NNODE_1D >
	General QSpectralElement class specialised to three spatial dimensions. More...
class	QSpectralEulerElement
class	QSpectralPoissonElement
	QSpectralPoissonElement elements are linear/quadrilateral/brick-shaped Poisson elements with isoparametric spectral interpolation for the function. Note that the implementation is PoissonEquations<DIM> does not use sum factorisation for the evaluation of the residuals and is, therefore, not optimal for higher dimensions. More...
class	QSpectralScalarAdvectionElement
class	QSphericalAdvectionDiffusionElement
	QSphericalAdvectionDiffusionElement elements are linear/quadrilateral/brick-shaped Axisymmetric Advection Diffusion elements with isoparametric interpolation for the function. More...
class	QSphericalCrouzeixRaviartElement
	Crouzeix_Raviart elements are Navier–Stokes elements with quadratic interpolation for velocities and positions, but a discontinuous linear pressure interpolation. They can be used within oomph-lib's block preconditioning framework. More...
class	QSphericalTaylorHoodElement
	Taylor–Hood elements are Navier–Stokes elements with quadratic interpolation for velocities and positions and continous linear pressure interpolation. They can be used within oomph-lib's block-preconditioning framework. More...
class	QSteadyAxisymAdvectionDiffusionElement
	QSteadyAxisymAdvectionDiffusionElement elements are linear/quadrilateral/brick-shaped Axisymmetric Advection Diffusion elements with isoparametric interpolation for the function. More...
class	QSUPGAdvectionDiffusionElement
	QSUPGAdvectionDiffusionElement<DIM,NNODE_1D> elements are SUPG-stabilised Advection Diffusion elements with NNODE_1D nodal points in each coordinate direction. Inherits from QAdvectionDiffusionElement and overwrites their test functions. More...
class	QTaylorHoodElement
	Taylor–Hood elements are Navier–Stokes elements with quadratic interpolation for velocities and positions and continuous linear pressure interpolation. They can be used within oomph-lib's block-preconditioning framework. More...
class	QTaylorHoodMixedOrderSpaceTimeElement
	Taylor-Hood elements are Navier-Stokes elements with quadratic interpolation for velocities and positions and continuous linear pressure interpolation. They can be used within oomph-lib's block-preconditioning framework. More...
class	QTimeHarmonicFourierDecomposedLinearElasticityElement
	An Element that solves the equations of Fourier decomposed (in cylindrical polars) time-harmonic linear elasticity, using QElements for the geometry. More...
class	QTimeHarmonicLinearElasticityElement
	An Element that solves the equations of linear elasticity in Cartesian coordinates, using QElements for the geometry. More...
class	QuadElementBase
	Base class for all quad elements. More...
class	QuadFromTriangleMesh
	Quad mesh built on top of triangle scaffold mesh coming from the triangle mesh generator Triangle. http://www.cs.cmu.edu/~quake/triangle.html. More...
class	QuadMeshBase
	Base class for quad meshes (meshes made of 2D quad elements). More...
class	QuadTree
	QuadTree class: Recursively defined, generalised quadtree. More...
class	QuadTreeForest
	A QuadTreeForest consists of a collection of QuadTreeRoots. Each member tree can have neighbours to its S/W/N/E and the orientation of their compasses can differ, allowing for complex, unstructured meshes. More...
class	QuadTreeRoot
	QuadTreeRoot is a QuadTree that forms the root of a (recursive) quadtree. The "root node" is special as it holds additional information about its neighbours and their relative rotation (inside a QuadTreeForest). More...
class	QuarterCircleSectorDomain
	Circular sector as domain. Domain is bounded by curved boundary which is represented by a GeomObject. Domain is parametrised by three macro elements. More...
class	QuarterCircleSectorMesh
	2D quarter ring mesh class. The domain is specified by the GeomObject that identifies boundary 1. More...
class	QuarterPipeDomain
	Domain representing a quarter pipe. More...
class	QuarterPipeMesh
	Non refineable quarter pipe mesh class Deform a simple cubic mesh into a quarter pipe r: radial direction theta: azimuthal direction z: axis direction. More...
class	QuarterTubeDomain
	Quarter tube as domain. Domain is bounded by curved boundary which is represented by a GeomObject. Domain is parametrised by three macro elements in each of the nlayer slices. More...
class	QuarterTubeMesh
	3D quarter tube mesh class. The domain is specified by the GeomObject that identifies boundary 3. Non-refineable base version! More...
class	QUnsteadyHeatElement
	QUnsteadyHeatElement elements are linear/quadrilateral/brick-shaped UnsteadyHeat elements with isoparametric interpolation for the function. More...
class	QUnsteadyHeatMixedOrderSpaceTimeElement
	QUnsteadyHeatMixedOrderSpaceTimeElement elements are quadrilateral/brick- shaped UnsteadyHeatMixedOrder elements with isoparametric interpolation for the function. More...
class	QUnsteadyHeatSpaceTimeElement
	QUnsteadyHeatSpaceTimeElement elements are quadrilateral/brick- shaped UnsteadyHeat elements with isoparametric interpolation for the function. More...
class	QWomersleyElement
	QWomersleyElement elements are linear/quadrilateral/brick-shaped Womersley elements with isoparametric interpolation for the function. More...
class	QYoungLaplaceElement
	QYoungLaplaceElement elements are linear/quadrilateral/brick-shaped YoungLaplace elements with isoparametric interpolation for the function. More...
class	RankFiveTensor
	A Rank 5 Tensor class. More...
class	RankFourTensor
	A Rank 4 Tensor class. More...
class	RankThreeTensor
	A Rank 3 Tensor class. More...
class	RanOutOfIterationsInSegregatedSolverError
	////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
class	RectangleWithHoleAndAnnularRegionDomain
	Rectangular domain with circular whole DRAIG: This looks like a redefinition of the RectangleWithHoleAndAnnularRegionDomain in src/meshes but it creates 8 macro-elements instead of 4 macro-elements and creates an annular region around the cylinder. It's probably a good idea to rename this class to avoid ambiguity and a name clash... More...
class	RectangleWithHoleAndAnnularRegionMesh
	Domain-based mesh for rectangular mesh with circular hole. More...
class	RectangleWithHoleDomain
	Rectangular domain with circular whole. More...
class	RectangleWithHoleMesh
	Domain-based mesh for rectangular mesh with circular hole. More...
class	RectangularQuadMesh
	RectangularQuadMesh is a two-dimensional mesh of Quad elements with Nx elements in the "x" (horizonal) direction and Ny elements in the "y" (vertical) direction. Two Constructors are provided. The basic constructor assumes that the lower-left-hand corner of the mesh is (0,0) and takes only the arguments, Nx, Ny, Xmax and Ymax. The more complex constructor takes the additional arguments Xmin and Ymin. More...
class	RefineableAdvectionDiffusionBoussinesqElement
	Build an AdvectionDiffusionElement that inherits from ElementWithExternalElement so that it can "communicate" with the a NavierStokesElement that provides its wind. More...
class	RefineableAdvectionDiffusionEquations
	A version of the Advection Diffusion equations that can be used with non-uniform mesh refinement. In essence, the class overloads the fill_in_generic_residual_contribution_adv_diff() function so that contributions from hanging nodes (or alternatively in-compatible function values) are taken into account. More...
class	RefineableAdvectionDiffusionReactionEquations
	A version of the Advection Diffusion Reaction equations that can be used with non-uniform mesh refinement. In essence, the class overloads the fill_in_generic_residual_contribution_adv_diff_react() function so that contributions from hanging nodes (or alternatively in-compatible function values) are taken into account. More...
class	RefineableAlgebraicChannelWithLeafletMesh
	Refineable version of algebraic ChannelWithLeafletMesh. More...
class	RefineableAlgebraicCollapsibleChannelMesh
	Refineable version of the CollapsibleChannel mesh with algebraic node update. More...
class	RefineableAlgebraicCylinderWithFlagMesh
	Refineable version of AlgebraicCylinderWithFlagMesh. More...
class	RefineableAlgebraicFSIDrivenCavityMesh
	Refineable version algebraic FSIDrivenCavityMesh. More...
class	RefineableAxisymAdvectionDiffusionEquations
	A version of the Advection Diffusion in axisym coordinates equations that can be used with non-uniform mesh refinement. In essence, the class overloads the fill_in_generic_residual_contribution_axisym_adv_diff() function so that contributions from hanging nodes (or alternatively in-compatible function values) are taken into account. More...
class	RefineableAxisymmetricNavierStokesEquations
	Refineable version of the Axisymmetric Navier–Stokes equations. More...
class	RefineableAxisymmetricQCrouzeixRaviartElement
	Refineable version of Axisymmetric Quad Crouzeix Raviart elements (note that unlike the cartesian version this is not scale-able to higher dimensions!) More...
class	RefineableAxisymmetricQTaylorHoodElement
	Refineable version of Axisymmetric Quad Taylor Hood elements. (note that unlike the cartesian version this is not scale-able to higher dimensions!) More...
class	RefineableBackwardStepQuadMesh
	Refineable backward step mesh. More...
class	RefineableBinArrayParameters
	Helper object for dealing with the parameters used for the RefineableBinArray objects. More...
class	RefineableBrickFromTetMesh
	Refineable brick mesh built by brickifying an existing tet mesh – each tet gets split into four bricks. Can only be built with quadratic (27 node) elements. More...
class	RefineableBrickMesh
	Intermediate mesh class that implements the mesh adaptation functions specified in the TreeBasedRefineableMesh class for meshes that contain the refineable variant of QElement s [The class ELEMENT provided as the template parameter must be of type RefineableQElement<3>]. More...
class	RefineableBuoyantQCrouzeixRaviartElement
	A RefineableElement class that solves the Boussinesq approximation of the Navier–Stokes and energy equations by coupling two pre-existing classes. The RefineableQAdvectionDiffusionElement with bi-quadratic interpolation for the scalar variable (temperature) and RefineableQCrouzeixRaviartElement which solves the Navier–Stokes equations using bi-quadratic interpolation for the velocities and a discontinuous bi-linear interpolation for the pressure. Note that we are free to choose the order in which we store the variables at the nodes. In this case we choose to store the variables in the order fluid velocities followed by temperature. We must, therefore, overload the function AdvectionDiffusionEquations<DIM>::u_index_adv_diff() to indicate that the temperature is stored at the DIM-th position not the 0-th. We do not need to overload the corresponding function in the NavierStokesEquations<DIM> class because the velocities are stored first. Finally, we choose to use the flux-recovery calculation from the fluid velocities to provide the error used in the mesh adaptation. More...
class	RefineableChannelWithLeafletMesh
	Refineable version of ChannelWithLeafletMesh. More...
class	RefineableCollapsibleChannelMesh
	Refineable collapsible channel mesh. The mesh is derived from the SimpleRectangularQuadMesh so it's node and element numbering scheme is the same as in that mesh. Only the boundaries are numbered differently to allow the easy identification of the "collapsible" segment. Boundary coordinates are set up for all nodes located on boundary 3 (the collapsible segment). The curvilinear ("collapsible") segment is defined by a GeomObject. More...
class	RefineableCylinderWithFlagMesh
	Refineable version of CylinderWithFlagMesh. More...
class	RefineableEighthSphereMesh
	Refineable version of the eight of a sphere brick mesh. The eighth-sphere is located in the positive octant, centred at the origin. The mesh boundaries are numbered as follows: More...
class	RefineableElement
	RefineableElements are FiniteElements that may be subdivided into children to provide a better local approximation to the solution. After non-uniform refinement adjacent elements need not necessarily have nodes in common. A node that does not have a counterpart in its neighbouring element is known as a hanging node and its position and any data that it stores must be constrained to ensure inter-element continuity. More...
class	RefineableExtrudedCubeMeshFromQuadMesh
	Mesh class that takes a 2D mesh, "extrudes" it in the z-direction and also makes the resulting mesh refineable. More...
class	RefineableFishMesh
	Refineable fish shaped mesh. The geometry is defined by the Domain object FishDomain. More...
class	RefineableFpPressureAdvDiffRobinBCElement
	A class for elements that allow the imposition of Robin boundary conditions for the pressure advection diffusion problem in the Fp preconditioner. The geometrical information can be read from the FaceGeometery<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	RefineableFpPressureAdvDiffRobinBCMixedOrderSpaceTimeElement
	A class for elements that allow the imposition of Robin boundary conditions for the pressure advection diffusion problem in the Fp preconditioner. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	RefineableFSIDrivenCavityMesh
	Refineable version of FSIDrivenCavityMesh. The mesh is derived from the SimpleRectangularQuadMesh so it's node and element numbering scheme is the same as in that mesh. Only the boundaries are numbered differently to allow the easy identification of the "collapsible" segment. Boundary coordinates are set up for all nodes located on boundary 3 (the collapsible segment). The curvilinear ("collapsible") segment is defined by a GeomObject. More...
class	RefineableFSIImposeDisplacementByLagrangeMultiplierElement
	A class for elements that allow the imposition of a displacement constraint for bulk solid elements via a Lagrange multiplier. Prescribed displaced is obtained from an adjacent bulk solid element (rather than from a lower-dimensional GeomObject as in the corresponding ImposeDisplacementByLagrangeMultiplierElement class. The present class is particularly suited for parallel FSI computations. NOTE: Currently (and for the foreseeable future) this element only works with bulk elements that do not have generalised degrees of freedom (so it won't work with Hermite-type elements, say). The additional functionality to deal with such elements could easily be added (once a a suitable test case is written). For now we simply throw errors if an attempt is made to use the element with an unsuitable bulk element. More...
class	RefineableFSISolidTractionElement
	RefineableSolidTractionElement "upgraded" to a FSIWallElement (and thus, by inheritance, a GeomObject), so it can be used in FSI. The element is templated by the bulk solid element and the spatial (Eulerian) dimension of the bulk element. More...
class	RefineableFullCircleMesh
	Adaptative version of the FullCircleMesh base mesh. The domain is specified by the GeomObject that identifies the entire area. More...
class	RefineableGeneralisedAdvectionDiffusionEquations
	A version of the GeneralisedAdvection Diffusion equations that can be used with non-uniform mesh refinement. In essence, the class overloads the fill_in_generic_residual_contribution_cons_adv_diff() function so that contributions from hanging nodes (or alternatively in-compatible function values) are taken into account. More...
class	RefineableGeneralisedAxisymAdvectionDiffusionEquations
	A version of the GeneralisedAxisymAdvectionDiffusion equations that can be used with non-uniform mesh refinement. In essence, the class overloads the fill_in_generic_residual_contribution_cons_axisym_adv_diff() function so that contributions from hanging nodes (or alternatively in-compatible function values) are taken into account. More...
class	RefineableGeneralisedNewtonianAxisymmetricNavierStokesEquations
	Refineable version of the Axisymmetric Navier–Stokes equations. More...
class	RefineableGeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement
	Refineable version of Axisymmetric Quad Crouzeix Raviart elements (note that unlike the cartesian version this is not scale-able to higher dimensions!) More...
class	RefineableGeneralisedNewtonianAxisymmetricQTaylorHoodElement
	Refineable version of Axisymmetric Quad Taylor Hood elements. (note that unlike the cartesian version this is not scale-able to higher dimensions!) More...
class	RefineableGeneralisedNewtonianNavierStokesEquations
	Refineable version of the Navier–Stokes equations. More...
class	RefineableGeneralisedNewtonianQCrouzeixRaviartElement
	Refineable version of Crouzeix Raviart elements. Generic class definitions. More...
class	RefineableGeneralisedNewtonianQTaylorHoodElement
	Refineable version of Taylor Hood elements. These classes can be written in total generality. More...
class	RefineableGmshTetMesh
class	RefineableHelmholtzEquations
	Refineable version of Helmholtz equations. More...
class	RefineableImposeDisplacementByLagrangeMultiplierElement
	A class for elements that allow the imposition of a displacement constraint for "bulk" solid elements via a Lagrange multiplier. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. NOTE: Currently (and for the foreseeable future) this element only works with bulk elements that do not have generalised degrees of freedom (so it won't work with Hermite-type elements, say). The additional functionality to deal with such elements could easily be added (once a a suitable test case is written). For now we simply throw errors if an attempt is made to use the element with an unsuitable bulk element. More...
class	RefineableLinearElasticityEquations
	Class for Refineable LinearElasticity equations. More...
class	RefineableLinearisedAxisymmetricNavierStokesEquations
	Refineable version of the linearised axisymmetric Navier–Stokes equations. More...
class	RefineableLinearisedAxisymmetricQCrouzeixRaviartElement
	Refineable version of linearised axisymmetric quadratic Crouzeix-Raviart elements. More...
class	RefineableLinearisedAxisymmetricQTaylorHoodElement
	Refineable version of linearised axisymmetric quadratic Taylor-Hood elements. More...
class	RefineableLinearisedNavierStokesEquations
	Refineable version of the linearised axisymmetric Navier–Stokes equations. More...
class	RefineableLinearisedQCrouzeixRaviartElement
	Refineable version of linearised axisymmetric quadratic Crouzeix-Raviart elements. More...
class	RefineableLinearisedQTaylorHoodElement
	Refineable version of linearised axisymmetric quadratic Taylor-Hood elements. More...
class	RefineableLinearWaveEquations
	Refineable version of LinearWave equations. More...
class	RefineableLineMesh
	Intermediate mesh class that implements the mesh adaptation functions specified in the RefineableMesh class for meshes that contain the refineable variant of QElement s [The class ELEMENT provided as the template parameter must be of type RefineableQElement<1>]. More...
class	RefineableMeshBase
	Base class for refineable meshes. Provides standardised interfaces for the following standard mesh adaptation routines: More...
class	RefineableNavierStokesBoussinesqElement
	Build a refineable Navier Stokes element that inherits from ElementWithExternalElement so that it can "communicate" with an advection diffusion element that provides the temperature in the body force term. More...
class	RefineableNavierStokesEquations
	Refineable version of the Navier–Stokes equations. More...
class	RefineableNavierStokesFluxControlElement
	A class of element to impose an applied boundary pressure to Navier-Stokes elements to control to control a volume flux. A mesh of these elements are used in conjunction with a NetFluxControlElement. The template arguement ELEMENT is a Navier-Stokes "bulk" element. More...
class	RefineableNavierStokesMixedOrderSpaceTimeTractionElement
	A class for elements that allow the imposition of an applied traction to the Navier–Stokes equations The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	RefineableNavierStokesTractionElement
	A class for elements that allow the imposition of an applied traction to the Navier–Stokes equations The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	RefineableOneDMesh
	Refineable version of the OneDMesh. More...
class	RefineablePMLHelmholtzEquations
	Refineable version of PMLHelmholtz equations. More...
class	RefineablePoissonEquations
	Refineable version of Poisson equations. More...
class	RefineablePolarCrouzeixRaviartElement
	Refineable version of Crouzeix Raviart elements. Generic class definitions. More...
class	RefineablePolarNavierStokesEquations
	Refineable version of my Polar Navier–Stokes equations. More...
class	RefineablePolarTaylorHoodElement
	Refineable version of Polar Taylor Hood elements. These classes can be written in total generality. More...
class	RefineablePseudoSolidNodeUpdateElement
	Refineable version of the PseudoSolidNodeUpdateELement. More...
class	RefineablePVDEquations
	Class for Refineable PVD equations. More...
class	RefineablePVDEquationsWithPressure
	Class for Refineable solid mechanics elements in near-incompressible/ incompressible formulation, so a pressure is included! In this case, the pressure interpolation is discontinuous, a la Crouzeix Raviart. More...
class	RefineableQAdvectionDiffusionElement
	Refineable version of QAdvectionDiffusionElement. Inherit from the standard QAdvectionDiffusionElement and the appropriate refineable geometric element and the refineable equations. More...
class	RefineableQAdvectionDiffusionReactionElement
	Refineable version of QAdvectionDiffusionReactionElement. Inherit from the standard QAdvectionDiffusionReactionElement and the appropriate refineable geometric element and the refineable equations. More...
class	RefineableQAxisymAdvectionDiffusionElement
	Refineable version of QAxisymAdvectionDiffusionElement. Inherit from the standard QAxisymAdvectionDiffusionElement and the appropriate refineable geometric element and the refineable equations. More...
class	RefineableQCrouzeixRaviartElement
	Refineable version of Crouzeix Raviart elements. Generic class definitions. More...
class	RefineableQElement
	A class that is used to template the refineable Q elements by dimension. It's really nothing more than a policy class. More...
class	RefineableQElement< 1 >
	Refineable version of QElement<1,NNODE_1D>. More...
class	RefineableQElement< 2 >
	Refineable version of QElement<2,NNODE_1D>. More...
class	RefineableQElement< 3 >
	Refineable version of QElement<3,NNODE_1D>. More...
class	RefineableQGeneralisedAdvectionDiffusionElement
	Refineable version of QGeneralisedAdvectionDiffusionElement. Inherit from the standard QGeneralisedAdvectionDiffusionElement and the appropriate refineable geometric element and the refineable equations. More...
class	RefineableQGeneralisedAxisymAdvectionDiffusionElement
	Refineable version of QGeneralisedAxisymAdvectionDiffusionElement. Inherit from the standard QGeneralisedAxisymAdvectionDiffusionElement and the appropriate refineable geometric element and the refineable equations. More...
class	RefineableQHelmholtzElement
	Refineable version of 2D QHelmholtzElement elements. More...
class	RefineableQLinearElasticityElement
	Class for refineable QLinearElasticityElement elements. More...
class	RefineableQLinearWaveElement
	Refineable version of 2D QLinearWaveElement elements. More...
class	RefineableQPMLHelmholtzElement
	Refineable version of QPMLHelmholtzElement elements. More...
class	RefineableQPoissonElement
	Refineable version of 2D QPoissonElement elements. More...
class	RefineableQPVDElement
	Class for refineable QPVDElement elements. More...
class	RefineableQPVDElementWithContinuousPressure
	Class for refineable solid mechanics elements in near-incompressible/ incompressible formulation, so a pressure is included! These elements include a continuously interpolated pressure a la Taylor Hood/. More...
class	RefineableQPVDElementWithPressure
	Class for refineable solid mechanics elements in near-incompressible/ incompressible formulation, so a pressure is included! In this case, the pressure interpolation is discontinuous, a la Crouzeix Raviart, and the displacement is always quadratic. More...
class	RefineableQSpectralElement
	A class that is used to template the refineable Q spectral elements by dimension. It's really nothing more than a policy class. More...
class	RefineableQSpectralElement< 1 >
	Refineable version of LineElements that add functionality for spectral Elements. More...
class	RefineableQSpectralElement< 2 >
	Refineable version of QuadElements that add functionality for spectral Elements. More...
class	RefineableQSpectralElement< 3 >
	Refineable version of QuadElements that add functionality for spectral Elements. More...
class	RefineableQSpectralPoissonElement
	Refineable version of 2D QSpectralPoissonElement elements. More...
class	RefineableQSphericalAdvectionDiffusionElement
	Refineable version of QSphericalAdvectionDiffusionElement. Inherit from the standard QSphericalAdvectionDiffusionElement and the appropriate refineable geometric element and the refineable equations. More...
class	RefineableQSphericalCrouzeixRaviartElement
	Refineable version of Spherical Quad Crouzeix Raviart elements (note that unlike the cartesian version this is not scale-able to higher dimensions!) More...
class	RefineableQSphericalTaylorHoodElement
	Refineable version of Spherical Quad Taylor Hood elements. (note that unlike the cartesian version this is not scale-able to higher dimensions!) More...
class	RefineableQSUPGAdvectionDiffusionElement
	Refineable version of QSUPGAdvectionDiffusionElement. Inherit from the standard QSUPGAdvectionDiffusionElement and the appropriate refineable geometric element and the refineable equations. More...
class	RefineableQTaylorHoodElement
	Refineable version of Taylor Hood elements. These classes can be written in total generality. More...
class	RefineableQTaylorHoodMixedOrderSpaceTimeElement
	Refineable version of Taylor Hood elements. These classes can be written in total generality. More...
class	RefineableQTimeHarmonicLinearElasticityElement
	Class for refineable QTimeHarmonicLinearElasticityElement elements. More...
class	RefineableQuadFromTriangleMesh
	Unstructured refineable QuadFromTriangleMesh. More...
class	RefineableQuadMesh
	Intermediate mesh class that implements the mesh adaptation functions specified in the TreeBasedRefineableMesh class for meshes that contain the refineable variant of QElement s [The class ELEMENT provided as the template parameter must be of type RefineableQElement<2>]. More...
class	RefineableQuadMeshWithMovingCylinder
	My Mesh. More...
class	RefineableQuarterCircleSectorMesh
	2D quarter ring mesh class inherited from RefineableQuadMesh. The domain is specified by the GeomObject that identifies boundary 1. More...
class	RefineableQuarterPipeMesh
	Refineable quarter pipe mesh class. More...
class	RefineableQuarterTubeMesh
	Adaptative version of the QuarterTubeMesh base mesh. The domain is specified by the GeomObject that identifies boundary 3. More...
class	RefineableQUnsteadyHeatElement
	Refineable version of 2D QUnsteadyHeatElement elements. More...
class	RefineableQUnsteadyHeatMixedOrderSpaceTimeElement
	Refineable version of 2D QUnsteadyHeatMixedOrderSpaceTimeElement elements. More...
class	RefineableQUnsteadyHeatSpaceTimeElement
	Refineable version of 2D QUnsteadyHeatSpaceTimeElement elements. More...
class	RefineableQYoungLaplaceElement
	Refineable version of 2D QYoungLaplaceElement elements. More...
class	RefineableRectangleWithHoleAndAnnularRegionMesh
	Refineable version of RectangleWithHoleAndAnnularRegionMesh. Applies one uniform refinement immediately to avoid problems with the automatic applications of boundary conditions in subsequent refinements. More...
class	RefineableRectangleWithHoleMesh
	Refineable version of RectangleWithHoleMesh. For some reason this needs on uniform refinement to work... More...
class	RefineableRectangularQuadMesh
	Refineable version of the RectangularQuadMesh: A two-dimensional mesh of Quad elements with Nx elements in the "x" (horizonal) direction and Ny elements in the "y" (vertical) direction. Two Constructors are provided. The basic constructor assumes that the lower-left-hand corner of the mesh is (0,0) and takes only the arguments, Nx, Ny, Xmax and Ymax. The more complex constructor takes the additional arguments Xmin and Ymin. More...
class	RefineableSimpleCubicMesh
	Refineable version of simple cubic 3D Brick mesh class. More...
class	RefineableSolidBrickFromTetMesh
	Refineable solid brick mesh built by brickifying an existing tet mesh – each tet gets split into four bricks. Can only be built with quadratic (27 node) elements. More...
class	RefineableSolidElement
	RefineableSolidElements are SolidFiniteElements that may be subdivided into children to provide a better local approximation to the solution. The distinction is required to keep a clean separation between problems that alter nodal positions and others. A number of procedures are generic and are included in this class. More...
class	RefineableSolidQElement
	A class that is used to template the solid refineable Q elements by dimension. It's really nothing more than a policy class. More...
class	RefineableSolidQElement< 1 >
	Refineable version of Solid line elements. More...
class	RefineableSolidQElement< 2 >
	Refineable version of Solid quad elements. More...
class	RefineableSolidQElement< 3 >
	Refineable version of Solid brick elements. More...
class	RefineableSolidQuadFromTriangleMesh
	Unstructured refineable QuadFromTriangleMesh upgraded to solid mesh. More...
class	RefineableSolidTetgenMesh
class	RefineableSolidThinLayerBrickOnTetMesh
	Refineable solid brick mesh layer built on top of a given tet mesh. Typically used in FSI problems where the tet mesh is the fluid mesh and this mesh acts as the solid mesh that surrounds the FSI interface. More...
class	RefineableSolidTractionElement
	A class for elements that allow the imposition of an applied traction in the principle of virtual displacements. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	RefineableSolidTriangleMesh
	Unstructured refineable Triangle Mesh upgraded to solid mesh. More...
class	RefineableSpaceTimeNavierStokesMixedOrderEquations
	Refineable version of the Navier-Stokes equations. More...
class	RefineableSpaceTimeUnsteadyHeatEquations
	Refineable version of Unsteady Heat equations. More...
class	RefineableSpaceTimeUnsteadyHeatMixedOrderEquations
	Refineable version of Unsteady Heat equations. More...
class	RefineableSphericalAdvectionDiffusionEquations
	A version of the Advection Diffusion in spherical coordinates equations that can be used with non-uniform mesh refinement. In essence, the class overloads the fill_in_generic_residual_contribution_spherical_adv_diff() function so that contributions from hanging nodes (or alternatively in-compatible function values) are taken into account. More...
class	RefineableSphericalNavierStokesEquations
	Refineable version of the Spherical Navier–Stokes equations. More...
class	RefineableTetgenMesh
class	RefineableTetMeshBase
	Base class for refineable tet meshes. More...
class	RefineableThinLayerBrickOnTetMesh
	Refineable brick mesh layer built on top of a given tet mesh. Typically used in FSI problems where the tet mesh is the fluid mesh and this mesh acts as the solid mesh that surrounds the FSI interface. More...
class	RefineableTimeHarmonicLinearElasticityEquations
	Class for Refineable TimeHarmonicLinearElasticity equations. More...
class	RefineableTriangleMesh
	Unstructured refineable Triangle Mesh. More...
class	RefineableTubeMesh
	Adaptative version of the TubeMesh base mesh. The domain is specified by the GeomObject that identifies the entire volume. More...
class	RefineableTwoDAnnularMesh
	Refineable 2D annular mesh with a unit circle in the middle and a layer of thickness h surrounding it. More...
class	RefineableUnsteadyHeatEquations
	Refineable version of Unsteady HEat equations. More...
class	RefineableYoungLaplaceEquations
	Refineable version of YoungLaplace equations. More...
class	RungeKutta
	=========================================================== Standard Runge Kutta Timestepping More...
class	SamplePointContainerParameters
	Helper object for dealing with the parameters used for the SamplePointContainer objects. More...
class	ScalarAdvectionEquations
	Base class for advection equations. More...
class	SegregatableFSIProblem
	Base class for problems that can be solved by segregated FSI solver. More...
class	SegregatedSolverError
	A class to handle errors in the Segregated solver. More...
class	Shape
	A Class for shape functions. In simple cases, the shape functions have only one index that can be thought of as corresponding to the nodal points. In general, however, when quantities and their gradients are interpolated separately, the shape function have two indices: one corresponding to the nodal points, and the other to the "type" of quantity being interpolated: function, derivative, &c The second index can also represent the vector coordinate for vector-valued (Nedelec) shape functions. More...
class	ShapeWithDeepCopy
	A shape function with a deep copy constructor. This allows for use with stl operations (e.g. manipulating vectors of shape functions). A seperate class is needed because the basic shape function uses a shallow copy. More...
class	SimpleCubicMesh
	Simple cubic 3D Brick mesh class. More...
class	SimpleCubicScaffoldTetMesh
	Scaffold mesh for cubic tet mesh. More...
class	SimpleCubicTetMesh
	MySimple 3D tet mesh for TElements. More...
class	SimpleFSIPreconditioner
	FSI preconditioner. This extracts upper/lower triangular blocks in the 3x3 overall block matrix structure arising from the monolithic discretisation of FSI problems with algebraic node updates. Dofs are decomposed into fluid velocity, pressure and solid unknowns. Blocks are then re-assembled into one global matrix and solved with a direct solver (SuperLU in its incarnation as an exact preconditioner). By default we retain the fluid on solid off diagonal blocks. More...
class	SimpleRectangularQuadMesh
	Simple rectangular 2D Quad mesh class. Nx : number of elements in the x direction. More...
class	SimpleRectangularTriMesh
	Simple 2D triangular mesh for TElements. More...
class	SingleLayerCubicSpineMesh
	Spine mesh class derived from standard cubic 3D mesh. The mesh contains a layer of spinified fluid elements (of type ELEMENT; e.g SpineElement<QCrouzeixRaviartElement<3>) for 3D problems, in which the interface's vertical position can vary. More...
class	SingleLayerSpineMesh
	Single-layer spine mesh class derived from standard 2D mesh. The mesh contains a layer of spinified fluid elements (of type ELEMENT; e.g SpineElement<QCrouzeixRaviartElement<2>). It constructs the spines and contains the information on how to update the nodal positions within the mesh as a function of the spine lengths. Equations that determine the spine heights (even if they are pinned) must be specified externally or else there will be problems. More...
class	SiskoTanMilRegWithBlendingConstitutiveEquation
	A GeneralisedNewtonianConstitutiveEquation class defining a Sisko fluid using Tanner and Milthorpe's (1983) regularisation with a smooth transition using a cubic (for n < 1) More...
class	SlopeLimiter
	Base class for slope limiters. More...
class	Smoother
	Smoother class: The smoother class is designed for to be used in conjunction with multigrid. The action of the smoother should reduce the high frequency errors. These methods are inefficient as stand-alone solvers. More...
class	SolidBrickFromTetMesh
	Solid brick mesh built by brickifying an existing tet mesh – each tet gets split into four bricks. Can only be built with quadratic (27 node) elements. More...
class	SolidDiagQHermiteElement
	SolidQHermiteElements in which we assume the local and global coordinates to be aligned so that the Jacobian of the mapping betwteen local and global coordinates is diagonal. This makes the evaluation of the derivatives of the shape functions much cheaper. More...
class	SolidElementWithDiagonalMassMatrix
	Pure virtual base class for elements that can be used with PressureBasedSolidLSCPreconditioner. More...
class	SolidFaceElement
	SolidFaceElements combine FaceElements and SolidFiniteElements and overload various functions so they work properly in the FaceElement context. More...
class	SolidFiniteElement
	SolidFiniteElement class. More...
class	SolidICProblem
	IC problem for an elastic body discretised on a given (sub)-mesh. We switch the elements' residuals and Jacobians to the system of equations that forces the wall shape to become that of a specified "initial condition object". More...
class	SolidInitialCondition
	A class to specify the initial conditions for a solid body. Solid bodies are often discretised with Hermite-type elements, for which the assignment of the generalised nodal values is nontrivial since they represent derivatives w.r.t. to the local coordinates. A SolidInitialCondition object specifies initial position (i.e. shape), velocity and acceleration of the structure with a geometric object. An integer specifies which time-derivative derivative is currently assigned. See example codes for a demonstration of its use. More...
class	SolidMesh
	General SolidMesh class. More...
class	SolidNode
	A Class for nodes that deform elastically (i.e. position is an unknown in the problem). The idea is that the Eulerian positions are stored in a Data object and the Lagrangian coordinates are stored in addition. The pointer that addresses the Eulerian positions is set to the pointer to Value in the Data object. Hence, SolidNode uses knowledge of the internal structure of Data and must be a friend of the Data class. In order to allow a mesh to deform via an elastic-style equation in deforming-domain problems, the positions are stored separately from the values, so that elastic problems may be combined with any other type of problem. More...
class	SolidPointElement
	Solid point element. More...
class	SolidQElement
	SolidQElement elements are quadrilateral elements whose derivatives also include those based upon the lagrangian positions of the nodes. They are the basis for solid mechanics elements. More...
class	SolidQElement< 1, NNODE_1D >
	SolidQElement elements, specialised to one spatial dimension. More...
class	SolidQElement< 2, NNODE_1D >
	SolidQElement elements, specialised to two spatial dimensions. More...
class	SolidQElement< 3, NNODE_1D >
	SolidQElement elements, specialised to three spatial dimensions. More...
class	SolidQHermiteElement
	SolidQHermiteElement elements are Hermite elements whose Jacobian matrices include derivatives w.r.t. the Eulerian positions of their nodes. They are the basis for elasticity elements. No assumptions are made about alignment of local and global coordinates. More...
class	SolidQuadFromTriangleMesh
	Unstructured QuadFromTriangleMesh upgraded to solid mesh. More...
class	SolidTBubbleEnrichedElement
	SolidTBubbleEnrichedElement elements are the enriched version of the SolidTElements. They will simply inherit from the appropriate SolidTElement and TBubblEnrichedElement. They are the basis for solid mechanics elements. More...
class	SolidTBubbleEnrichedElement< DIM, 3 >
	Specify the SolidTBubbleEnrichedElement corresponding to the quadratic triangle. More...
class	SolidTElement
	SolidTElement elements are triangular/tet elements whose derivatives also include those based upon the lagrangian positions of the nodes. They are the basis for solid mechanics elements. More...
class	SolidTElement< 1, NNODE_1D >
	SolidTElement elements, specialised to one spatial dimension. More...
class	SolidTElement< 2, NNODE_1D >
	SolidTElement elements, specialised to two spatial dimensions. More...
class	SolidTElement< 3, NNODE_1D >
	SolidTElement elements, specialised to three spatial dimensions. More...
class	SolidTetgenMesh
	Tetgen-based mesh upgraded to become a solid mesh. Automatically enumerates all boundaries. More...
class	SolidThinLayerBrickOnTetMesh
	Solid brick mesh layer built on top of a given tet mesh. Typically used in FSI problems where the tet mesh is the fluid mesh and this mesh acts as the solid mesh that surrounds the FSI interface. More...
class	SolidTractionElement
	A class for elements that allow the imposition of an applied traction in the principle of virtual displacements. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	SolidTriangleMesh
	Unstructured Triangle Mesh upgraded to solid mesh. More...
class	SolidXdaTetMesh
	Xda-based tet mesh upgraded to become a solid mesh. More...
class	SolutionFunctor
	Function class for a simple function with no external parameters (just stores a function pointer, only needed for compatability). More...
class	SolutionFunctorBase
	Function base class for exact solutions/initial conditions/boundary conditions. This is needed so that we can have solutions that depend on problem parameters with resorting to global variables. More...
class	SpaceTimeNavierStokesMixedOrderEquations
	A class for elements that solve the Cartesian Navier-Stokes equations, templated by the dimension DIM. This contains the generic maths – any concrete implementation must be derived from this. More...
class	SpaceTimeNavierStokesSubsidiaryPreconditioner
	General purpose block triangular preconditioner. By default this is Upper triangular. Also, by default ExactPreconditioner is used to solve the subsidiary systems, but other preconditioners can be used by setting them using passing a pointer to a function of type SubsidiaryPreconditionerFctPt to the method subsidiary_preconditioner_function_pt(). More...
class	SpaceTimeUnsteadyHeatEquations
	A class for all isoparametric elements that solve the SpaceTimeUnsteadyHeat equations. More...
class	SpaceTimeUnsteadyHeatEquationsBase
	Base class so that we don't need to know the dimension just to set the source function! More...
class	SpaceTimeUnsteadyHeatMixedOrderEquations
	A class for all isoparametric elements that solve the SpaceTimeUnsteadyHeatMixedOrder equations. More...
class	SparseMatrix
	Class for sparse matrices, that store only the non-zero values in a linear array in memory. The details of the array indexing vary depending on the storage scheme used. The MATRIX_TYPE template parameter for use in the curious recursive template pattern is included and passed directly to the base Matrix class. More...
class	SpectralElement
class	SpectralPeriodicOrbitElement
	QPoissonElement elements are linear/quadrilateral/brick-shaped Poisson elements with isoparametric interpolation for the function. More...
class	SphericalAdvectionDiffusionEquations
	A class for all elements that solve the Advection Diffusion equations in a spherical polar coordinate system using isoparametric elements. More...
class	SphericalAdvectionDiffusionFluxElement
	A class for elements that allow the imposition of an applied Robin boundary condition on the boundaries of Steady Axisymmnetric Advection Diffusion Flux elements. More...
class	SphericalNavierStokesEquations
	A class for elements that solve the Navier–Stokes equations, in axisymmetric spherical polar coordinates. This contains the generic maths – any concrete implementation must be derived from this. More...
class	Spine
	Spines are used for algebraic node update operations in free-surface fluid problems: They form the back-bones along which nodes in a a free-surface mesh are located. Typically, the free surface is located at the "end" of the spine; the nodes in the interior of the mesh are located at fixed fractions along the spine. The key Data member of the Spine object is its "height" – usually an unknown in the problem – which is used by the SpineNode's node update function to update the SpineNode's position. More...
class	SpineAxisymmetricFluidInterfaceElement
class	SpineAxisymmetricSurfactantTransportInterfaceElement
	Specialise to the Axisymmetric geometry. More...
class	SpineAxisymmetricVolumeConstraintBoundingElement
	The axisymmetric (one-dimensional) interface elements that allow imposition of a volume constraint specialised for the case when the nodal positions of the bulk elements are adjusted using Spines. To enforce that a fluid volume has a certain volume, attach these elements to all faces of the (2D axisymmetric) bulk fluid elements (of type ELEMENT) that bound that region and then specify the "pressure" value that is traded for the constraint. More...
class	SpineElement
	The SpineElement<ELEMENT> class takes an existing element as a template parameter and adds the necessary additional functionality to allow the element to be update using the Method of Spines. A vector of pointers to spines and storage for the local equation numbers associated with the spines are added to the element. More...
class	SpineFiniteElement
	A policy class that serves only to establish the interface for assigning the spine equation numbers. More...
class	SpineLineFluidInterfaceBoundingElement
	Spine version of the LineFluidInterfaceBoundingElement. More...
class	SpineLineFluidInterfaceElement
class	SpineLineSurfactantTransportInterfaceElement
	Specialise to the Line geometry. More...
class	SpineLineVolumeConstraintBoundingElement
	The one-dimensional interface elements that allow imposition of a volume constraint specialised for the case when the nodal positions of the bulk elements are adjusted using Spines. To enforce that a fluid volume has a certain volume, attach these elements to all faces of the (2D cartesian) bulk fluid elements (of type ELEMENT) that bound that region and then specify the "pressure" value that is traded for the constraint. More...
class	SpineMesh
	General SpineMesh class. More...
class	SpineNode
	Class for nodes that live on spines. The assumption is that each Node lies at a fixed fraction on a single spine (although more complex behaviour could be included by adding more variables to the spine). In general, more complex node updating should be handled by the classes implemented for algebraic node updates. More...
class	SpinePointFluidInterfaceBoundingElement
	Spine version of the PointFluidInterfaceBoundingElement. More...
class	SpineSurfaceFluidInterfaceElement
class	SpineSurfaceSurfactantTransportInterfaceElement
	Specialise to surface geometry. More...
class	SpineSurfaceVolumeConstraintBoundingElement
	The Two-dimensional interface elements that allow the application of a volume constraint specialised for the case when the nodal positions of the bulk elements are adjusted using spines. To enforce that a fluid volume has a certain volume, attach these elements to all faces of the (3D Cartesian) bulk fluid elements (of type ELEMENT) that bound that region and then specify the "pressure" value that is traded for the constraint. More...
class	SpineUpdateFluidInterfaceElement
	Generic Spine node update interface template class that can be combined with a given surface equations class and surface derivative class to provide a concrete implementation of any surface element that uses spines. More...
class	Steady
	Faux time-stepper for steady problems. Allows storage for NSTEPS previous values. More...
class	SteadyAxisymAdvectionDiffusionEquations
	A class for all elements that solve the Steady Axisymmetric Advection Diffusion equations using isoparametric elements. More...
class	SteadyAxisymAdvectionDiffusionFluxElement
	A class for elements that allow the imposition of an applied Robin boundary condition on the boundaries of Steady Axisymmnetric Advection Diffusion Flux elements. More...
class	StorableShapeElement
	Templated wrapper that attaches the ability to store the shape functions and their derivatives w.r.t. to the local and global (Eulerian) coordinates at the integration points to the element specified by the template parameter. More...
class	StorableShapeElementBase
	Base class for elements that allow storage of precomputed shape functions and their derivatives w.r.t to the local and global (Eulerian) coordinates at the element's integration points. More...
class	StorableShapeSolidElement
	Templated wrapper that attaches the ability to store the shape functions and their derivatives w.r.t. to the local and global (Eulerian) coordinates at the integration points to the SolidFiniteElement specified by the template parameter. More...
class	StorableShapeSolidElementBase
	Base class for solid elements that allow storage of precomputed shape functions and their derivatives w.r.t to the local and global (Lagrangian) coordinates at the element's integration points. More...
class	StraightLine
	Steady, straight 1D line in 2D space. More...
class	StrainEnergyFunction
	Base class for strain energy functions to be used in solid mechanics computations. More...
class	SumOfMatrices
	Class for a matrix of the form M = S + G + H + ... where S is the main matrix and G,H etc. are matrices of size S or smaller. This may be useful if, for example, G,H etc. are subblocks of M that must be stored in a different format to S. More...
class	SuperLUPreconditioner
	An interface to allow SuperLU to be used as an (exact) Preconditioner. More...
class	SuperLUSolver
	SuperLU Project Solver class. This is a combined wrapper for both SuperLU and SuperLU Dist. See http://crd.lbl.gov/~xiaoye/SuperLU/ Default Behaviour: If this solver is distributed over more than one processor then SuperLU Dist is used. Member data naming convention: member data associated with the SuperLU Dist solver begins Dist_... and member data associated with the serial SuperLU solver begins Serial_... . More...
class	SurfaceDerivatives
	Class that establishes the surface derivative functions for SurfaceInterfaceElements (2D surfaces in 3D space) These are defined in a separate class so that they can be used by other interface equation-type classes. More...
class	SurfaceVolumeConstraintBoundingElement
	Two-dimensional interface elements that allow the application of a volume constraint on the region bounded by these elements. The volume is computed by integrating x.n around the boundary of the domain and then dividing by three. The sign is chosen so that the volume will be positive when the elements surround a fluid domain. More...
class	SurfactantTransportInterfaceElement
	Generic surfactant transport equations implemented independently of the dimension and then specialised using the generic mechanisms introduce in the FluidInterfaceElements. More...
class	TAdvectionDiffusionReactionElement
	TAdvectionDiffusionReactionElement<NREAGENT,DIM,NNODE_1D> elements are isoparametric triangular DIM-dimensional AdvectionDiffusionReaction elements with NNODE_1D nodal points along each element edge. Inherits from TElement and AdvectionDiffusionReactionEquations. More...
class	TanhProfileConstitutiveEquation
	A GeneralisedNewtonianConstitutiveEquation class defining a fluid following a tanh-profile. More...
class	TAxisymmetricLinearElasticityElement
	TAxisymAxisymmetricLinearElasticityElement<NNODE_1D> elements are isoparametric triangular AxisymmetricLinearElasticity elements with NNODE_1D nodal points along each element edge. Inherits from TElement and AxisymmetricLinearElasticityEquations. More...
class	TAxisymmetricPoroelasticityElement
	================================================================= Element which solves the Darcy/linear elasticity equations using TElements Geometrically the element is always a six noded triangle. We use the mid-side nodes to store edge-based flux degrees of freedom and internal data for the discontinuous pressure More...
class	TBubbleEnrichedElement
	TElement class for which the shape functions have been enriched by a single bubble function of the next order. More...
class	TBubbleEnrichedElement< DIM, 3 >
	Enriched TElement class specialised to two spatial dimensions and three nodes per side (quadratic element) Ordering of nodes as in Zienkiwizc sketches: vertex nodes 0 - 1 - 2 anticlockwise. Midside nodes filled in progressing along the consecutive edges. Central node(s) come(s) last. The idea is that we inherit from the existing TElement<2,3>, add the single extra node at the centroid and overload the shape functions to be those corresponding to the enriched element. More...
class	TBubbleEnrichedElementShape
	A class for those member functions that must be fully specialised for Telements that are enriched by bubbble functions. The fact that member functions of partially specialised classes cannot necessarily be fully specialised means that we must either fully specialise every class, or use this base class to fully specialize only those functions that are required. More...
class	TBubbleEnrichedElementShape< 2, 3 >
	Specific Enriched TElementShape inline functions. More...
class	TBubbleEnrichedElementShape< 3, 3 >
	Standard quadratic shape functions enriched by the addition of three cubic "face" bubbles and quartic "volume" bubble, which consists of adding a node at the centroid of each face and a single node at the centroid of the tetrahedron. More...
class	TBubbleEnrichedGauss
	Define integration schemes that are required to exactly integrate the mass matrices of the bubble-enriched elements. The enrichement increases the polynomial order which means that higher-order Gauss rules must be used. More...
class	TBubbleEnrichedGauss< 2, 3 >
	Specialisation for two-dimensional elements, in which the highest order polynomial is cubic, so we need the integration scheme for the unenriched cubic element. More...
class	TBubbleEnrichedGauss< 3, 3 >
	Specialisation for three-dimensional elements, in which the highest order polynomial is quartic, so we need the integration scheme for the unenriched quartic element. More...
class	TCrouzeixRaviartElement
	TCrouzeix_Raviart elements are Navier–Stokes elements with quadratic interpolation for velocities and positions enriched by a single cubic bubble function, but a discontinuous linear pressure interpolation. More...
class	TDisplacementBasedFoepplvonKarmanElement
	TDisplacementBasedFoepplvonKarmanElement<NNODE_1D> elements are isoparametric triangular 2-dimensional Foeppl von Karman elements with NNODE_1D nodal points along each element edge. Inherits from TElement and DisplacementBasedFoepplvonKarmanEquations. More...
class	TElement
	General TElement class. More...
class	TElement< 1, NNODE_1D >
	General TElement class specialised to one spatial dimensions Ordering of nodes is 0 at local coordinate s[0] = 0, 1 at local coordinate s[0] = 1 and then filling in the intermediate values from s[0]=0 to 1. More...
class	TElement< 2, NNODE_1D >
	General TElement class specialised to two spatial dimensions Ordering of nodes as in Zienkiwizc sketches: vertex nodes 0 - 1 - 2 anticlockwise. Midside nodes filled in progressing along the consecutive edges. Central node(s) come(s) last. More...
class	TElement< 3, NNODE_1D >
	General TElement class specialised to three spatial dimensions (tet) Ordering of nodes inverted from Zienkiewizc sketches: When looking into the tet from vertex node 0. The vertex nodes on the opposite face are 1 - 2 - 3 in anticlockwise direction. Other nodes filled in edge by edge, then the face ones, then the internal ones. More...
class	TElementBase
	Empty base class for Telements (created so that we can use dynamic_cast<>() to figure out if a an element is a Telement). More...
class	TElementGeometricBase
	Empty base class for Telements (created so that we can use dynamic_cast<>() to figure out if a an element is a Telement (from a purely geometric point of view). More...
class	TElementShape
	A class for those member functions that must be fully specialised for the Telements. The fact that member functions of partially specialised classes cannot necessarily be fully specialised means that we must either fully specialise every class, or use this base class to fully specialize only those functions that are required. More...
class	TElementShape< 1, 2 >
	TElementShape inline functions: More...
class	TElementShape< 1, 3 >
class	TElementShape< 1, 4 >
class	TElementShape< 2, 2 >
class	TElementShape< 2, 3 >
class	TElementShape< 2, 4 >
class	TElementShape< 3, 2 >
	Return local coordinates of node j. More...
class	TElementShape< 3, 3 >
	Return local coordinates of node j. More...
class	TemplateFreeNavierStokesEquationsBase
	Template-free base class for Navier-Stokes equations to avoid casting problems. More...
class	TemplateFreeNavierStokesFluxControlElementBase
	A template free base class for an element to imposes an applied boundary pressure to the Navier-Stokes equations in order to control a volume flux when used in conjunction with a NetFluxControlElement or NetFluxControlElementForWomersleyPressureControl). More...
class	TemplateFreeSpaceTimeNavierStokesMixedOrderEquationsBase
	Template-free base class for Navier-Stokes equations to avoid casting problems. More...
class	TemplateFreeWomersleyImpedanceTubeBase
	Template-free base class for Impedance Tube – to faciliate interactions between the Womersley elements and the Navier Stokes impedance traction elements. More...
class	TemplateFreeWomersleyMeshBase
	Template-free base class. More...
class	TetEdge
	Helper class to keep track of edges in tet mesh generation. More...
class	TetgenMesh
	Unstructured tet mesh based on output from Tetgen: http://wias-berlin.de/software/tetgen/. More...
class	TetgenScaffoldMesh
	Mesh that is based on input files generated by the tetrahedra mesh generator tetgen. More...
class	TetMeshBase
	Base class for tet meshes (meshes made of 3D tet elements). More...
class	TetMeshFacet
	Facet for Tet mesh generation. Can lie on boundary (identified via one-based enumeration!) and can have GeomObject associated with those boundaries. More...
class	TetMeshFacetedClosedSurface
	Base class for closed tet mesh boundary bounded by polygonal planar facets. More...
class	TetMeshFacetedClosedSurfaceForRemesh
class	TetMeshFacetedSurface
	Base class for tet mesh boundary defined by polygonal planar facets. More...
class	TetMeshVertex
	Vertex for Tet mesh generation. Can lie on multiple boundaries (identified via one-based enumeration!) and can have intrinisic coordinates in a DiskLikeGeomObjectWithBoundaries. More...
class	TFace
	Triangular Face class. More...
class	TFoepplvonKarmanElement
	TFoepplvonKarmanElement<NNODE_1D> elements are isoparametric triangular 2-dimensional Foeppl von Karman elements with NNODE_1D nodal points along each element edge. Inherits from TElement and FoepplvonKarmanEquations. More...
class	TFourierDecomposedHelmholtzElement
	TFourierDecomposedHelmholtzElement<NNODE_1D> elements are isoparametric triangular FourierDecomposedHelmholtz elements with NNODE_1D nodal points along each element edge. Inherits from TElement and FourierDecomposedHelmholtzEquations. More...
class	TGauss
	Class for Gaussian integration rules for triangles/tets. More...
class	TGauss< 1, 2 >
	1D Gaussian integration class for linear "triangular" elements. Two integration points. This integration scheme can integrate up to second-order polynomials exactly and is therefore a suitable "full" integration scheme for linear (two-node) elements in which the highest-order polynomial is quadratic. More...
class	TGauss< 1, 3 >
	1D Gaussian integration class for quadratic "triangular" elements. Three integration points. This integration scheme can integrate up to fifth-order polynomials exactly and is therefore a suitable "full" integration scheme for quadratic (three-node) elements in which the highest-order polynomial is fourth order. More...
class	TGauss< 1, 4 >
	1D Gaussian integration class for cubic "triangular" elements. Four integration points. This integration scheme can integrate up to seventh-order polynomials exactly and is therefore a suitable "full" integration scheme for cubic (ten-node) elements in which the highest-order polynomial is sixth order. More...
class	TGauss< 1, 5 >
class	TGauss< 2, 13 >
class	TGauss< 2, 16 >
class	TGauss< 2, 2 >
	2D Gaussian integration class for linear triangles. Three integration points. This integration scheme can integrate up to second-order polynomials exactly and is therefore a suitable "full" integration scheme for linear (three-node) elements in which the highest-order polynomial is quadratic. More...
class	TGauss< 2, 3 >
	2D Gaussian integration class for quadratic triangles. Seven integration points. This integration scheme can integrate up to fifth-order polynomials exactly and is therefore a suitable "full" integration scheme for quadratic (six-node) elements in which the highest-order polynomial is fourth order. More...
class	TGauss< 2, 4 >
	2D Gaussian integration class for cubic triangles. Thirteen integration points. This integration scheme can integrate up to seventh-order polynomials exactly and is therefore a suitable "full" integration scheme for cubic (ten-node) elements in which the highest-order polynomial is sixth order. More...
class	TGauss< 2, 5 >
class	TGauss< 2, 9 >
class	TGauss< 3, 2 >
	3D Gaussian integration class for tets. Four integration points. This integration scheme can integrate up to second-order polynomials exactly and is therefore a suitable "full" integration scheme for linear (four-node) elements in which the highest-order polynomial is quadratic. More...
class	TGauss< 3, 3 >
	3D Gaussian integration class for tets. Eleven integration points. This integration scheme can integrate up to fourth-order polynomials exactly and is therefore a suitable "full" integration scheme for quadratic (ten-node) elements in which the highest-order polynomial is fourth order. The numbers are from Keast CMAME 55 pp339-348 (1986) More...
class	TGauss< 3, 5 >
	3D Gaussian integration class for tets. 45 integration points. This integration scheme can integrate up to eighth-order polynomials exactly and is therefore a suitable "full" integration scheme for quartic elements in which the highest-order polynomial is fourth order. The numbers are from Keast CMAME 55 pp339-348 (1986) More...
class	THelmholtzElement
	THelmholtzElement<DIM,NNODE_1D> elements are isoparametric triangular DIM-dimensional Helmholtz elements with NNODE_1D nodal points along each element edge. Inherits from TElement and HelmholtzEquations. More...
class	ThinLayerBrickOnTetMesh
	Brick mesh layer built on top of a given tet mesh. Typically used in FSI problems where the tet mesh is the fluid mesh and this mesh acts as the solid mesh that surrounds the FSI interface. More...
class	Time
	Class to keep track of discrete/continous time. It is essential to have a single Time object when using multiple time-stepping schemes; e.g., in fluid-structure interaction problems, it is common to use different schemes for the fluid and solid domains. Storage is allocated for the current value of the (continuous) time and a limited history of previous timesteps. The number of previous timesteps must be equal to the number required by the "highest order" scheme. More...
class	TimeHarmonicElasticityTensor
	A base class that represents the fourth-rank elasticity tensor defined such that. More...
class	TimeHarmonicFourierDecomposedLinearElasticityEquations
	A class for elements that solve the Fourier decomposed (in cylindrical polars) equations of time-harmonic linear elasticity. More...
class	TimeHarmonicFourierDecomposedLinearElasticityEquationsBase
	A base class for elements that solve the Fourier decomposed (in cylindrical polars) equations of time-harmonic linear elasticity. More...
class	TimeHarmonicFourierDecomposedLinearElasticityTractionElement
	A class for elements that allow the imposition of an applied traction in the equations of time-harmonic Fourier decomposed linear elasticity. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	TimeHarmonicIsotropicElasticityTensor
	An isotropic elasticity tensor defined in terms of Young's modulus and Poisson's ratio. The elasticity tensor is assumed to be non-dimensionalised on some reference value for Young's modulus so the value provided to the constructor (if any) is to be interpreted as the ratio of the actual Young's modulus to the Young's modulus used to non-dimensionalise the stresses/tractions in the governing equations. More...
class	TimeHarmonicLinearElasticityEquations
	A class for elements that solve the equations of linear elasticity in cartesian coordinates. More...
class	TimeHarmonicLinearElasticityEquationsBase
	A base class for elements that solve the equations of time-harmonic linear elasticity in Cartesian coordinates. Combines a few generic functions that are shared by TimeHarmonicLinearElasticityEquations and TimeHarmonicLinearElasticityEquationsWithPressure (Note: The latter don't exist yet but will be written as soon as somebody needs them...) More...
class	TimeHarmonicLinearElasticityTractionElement
	A class for elements that allow the imposition of an applied traction in the equations of time-harmonic linear elasticity. The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	TimeHarmonicLinElastLoadedByHelmholtzPressureBCElement
	A class for elements that allow the imposition of an applied traction in the equations of time-harmonic linear elasticity from a Helmholtz potential (interpreted as a displacement potential for the fluid in a quasi-steady, linearised FSI problem.) The geometrical information can be read from the FaceGeometry<ELEMENT> class and and thus, we can be generic enough without the need to have a separate equations class. More...
class	TimeHarmonicLinElastLoadedByPMLHelmholtzPressureBCElement
	A class for elements that allow the imposition of an applied traction in the equations of time-harmonic linear elasticity from a PMLHelmholtz potential (interpreted as a displacement potential for the fluid in a quasi-steady, linearised FSI problem.) The geometrical information can be read from the FaceGeometry<ELEMENT> class and thus, we can be generic enough without the need to have a separate equations class. More...
class	Timer
	Timer. More...
class	TimeStepper
	Base class for time-stepping schemes. Timestepper provides an approximation of the temporal derivatives of Data such that the i-th derivative of the j-th value in Data is represented as. More...
class	TLinearElasticityElement
	TLinearElasticityElement<DIM,NNODE_1D> elements are isoparametric triangular DIM-dimensional LinearElasticity elements with NNODE_1D nodal points along each element edge. Inherits from TElement and LinearElasticityEquations. More...
class	TopologicallyRectangularDomain
	Topologically Rectangular Domain - a domain dexcribing a topologically rectangular problem - primarily contains functions to access the position of the global boundary relative to the macro element boundary, as well as first and second derivates of the global boundary wrt the macro element boundary NOTE : suitable for HermiteElementQuadMesh. More...
class	TPMLFourierDecomposedHelmholtzElement
	TPMLFourierDecomposedHelmholtzElement<NNODE_1D> elements are isoparametric triangular PMLFourierDecomposedHelmholtz elements with NNODE_1D nodal points along each element edge. Inherits from TElement and PMLFourierDecomposedHelmholtzEquations. More...
class	TPMLHelmholtzElement
	TPMLHelmholtzElement<DIM,NNODE_1D> elements are isoparametric triangular DIM-dimensional PMLHelmholtz elements with NNODE_1D nodal points along each element edge. Inherits from TElement and PMLHelmholtzEquations. More...
class	TPMLTimeHarmonicLinearElasticityElement
	TPMLTimeHarmonicLinearElasticityElement<DIM,NNODE_1D> elements are isoparametric triangular DIM-dimensional PMLTimeHarmonicLinearElasticity elements with NNODE_1D nodal points along each element edge. Inherits from TElement and PMLTimeHarmonicLinearElasticityEquations. More...
class	TPoissonElement
	TPoissonElement<DIM,NNODE_1D> elements are isoparametric triangular DIM-dimensional Poisson elements with NNODE_1D nodal points along each element edge. Inherits from TElement and PoissonEquations. More...
class	TPoroelasticityElement
	Element which solves the Darcy equations using TElements. More...
class	TPVDBubbleEnrichedElement
	An Element that solves the solid mechanics equations, based on the principle of virtual displacements in Cartesian coordinates, using SolidTBubbleEnrichedElements for the interpolation of the variable positions. These elements are typically required when using pseudo-elasticity to move internal mesh nodes and TCrouzeixRaviartFluid elements. More...
class	TPVDElement
	An Element that solves the solid mechanics equations, based on the principle of virtual displacements in Cartesian coordinates, using SolidTElements for the interpolation of the variable positions. More...
class	TPVDElementWithContinuousPressure
	An Element that solves the solid mechanics equations in an (near) incompressible formulation with quadratic interpolation for velocities and positions and continous linear pressure interpolation. This is equivalent to the TTaylorHoodElement element for fluids. More...
class	TR
	Trapezoid rule time stepping scheme. More...
class	TRaviartThomasDarcyElement
	Element which solves the Darcy equations using TElements. Geometrically the element is always a six noded triangle. We use the mid-side nodes to store edge-based flux degrees of freedom and internal data for the discontinuous pressure and internal flux dofs. More...
class	Tree
	A generalised tree base class that abstracts the common functionality between the quad- and octrees used in mesh adaptation in two and three dimensions, respectively. More...
class	TreeBasedRefineableMesh
	Templated base class for refineable meshes. The use of the template parameter is required only for creating new elements during mesh adaptation. This class overloaded the template-free inteface to the function split_elements_if_required() to make use of the template parameter. All refineable meshes should inherit directly from TreeBasedRefineableMesh<ELEMENT> More...
class	TreeBasedRefineableMeshBase
	Base class for tree-based refineable meshes. More...
class	TreeForest
	A TreeForest consists of a collection of TreeRoots. Each member tree can have neighbours in various enumerated directions (e.g. S/W/N/E for a QuadTreeForest) and the orientation of their compasses can differ, allowing for complex, unstructured meshes. More...
class	TreeRoot
	TreeRoot is a Tree that forms the root of a (recursive) tree. The "root node" is special as it holds additional information about its neighbours and their relative rotation (inside a TreeForest). More...
class	TriangleMesh
	Triangle mesh build with the help of the scaffold mesh coming from the triangle mesh generator Triangle. http://www.cs.cmu.edu/~quake/triangle.html. More...
class	TriangleMeshBase
	Base class for triangle meshes (meshes made of 2D triangle elements). Note: we choose to template TriangleMeshBase here because certain functions in UnstructuredTwoDMeshGeometryBase need template parameters and it's much cleaner simply to template the entire class. More...
class	TriangleMeshClosedCurve
	Base class defining a closed curve for the Triangle mesh generation. More...
class	TriangleMeshCurve
	closed curves and open curves. All TriangleMeshCurves are composed of a Vector of TriangleMeshCurveSections More...
class	TriangleMeshCurveSection
	Base class for defining a triangle mesh boundary, this class has the methods that allow to connect the initial and final ends to other triangle mesh boundaries. More...
class	TriangleMeshCurviLine
	Class definining a curvilinear triangle mesh boundary in terms of a GeomObject. Curvlinear equivalent of PolyLine. More...
class	TriangleMeshOpenCurve
	Base class defining an open curve for the Triangle mesh generation Basically used to define internal boundaries on the mesh. More...
class	TriangleMeshParameters
	Helper object for dealing with the parameters used for the TriangleMesh objects. More...
class	TriangleMeshPolygon
	Class defining a closed polygon for the Triangle mesh generation. More...
class	TriangleMeshPolyLine
	Class defining a polyline for use in Triangle Mesh generation. More...
class	TriangleScaffoldMesh
	Triangle Mesh that is based on input files generated by the triangle mesh generator Triangle. More...
struct	TriangulateIO
	The Triangle data structure, modified from the triangle.h header supplied with triangle 1.6. by J. R. Schewchuk. We need to define this here separately because we can't include a c header directly into C++ code! More...
class	TrilinosAztecOOSolver
	An interface to the Trilinos AztecOO classes allowing it to be used as an Oomph-lib LinearSolver. The AztecOO solver is a Krylov Subspace solver; the solver type (either CG, GMRES or BiCGStab) can be set using solver_type(). This solver can be preconditioned with Trilinos Preconditioners (derived from TrilinosPreconditionerBase) or Oomph-lib preconditioners (derived from Preconditioner). Preconditioners are set using preconditioner_pt(). More...
class	TrilinosIFPACKPreconditioner
	An interface to the Trilinos IFPACK class- provides a function to construct an IFPACK object, and functions to modify some of the IFPACK paramaters. More...
class	TrilinosMLPreconditioner
	An interface to the Trilinos ML class - provides a function to construct a serial ML object, and functions to modify some of the ML paramaters. More...
class	TrilinosPreconditionerBase
	Base class for Trilinos preconditioners as oomph-lib preconditioner. More...
class	TSolidElementBase
	Base class for Solid Telements. More...
class	TTaylorHoodElement
	Taylor–Hood elements are Navier–Stokes elements with quadratic interpolation for velocities and positions and continous linear pressure interpolation. More...
class	TTimeHarmonicFourierDecomposedLinearElasticityElement
	An Element that solves the equations of Fourier decomposed (in cylindrical polars) time-harmonic linear elasticity, using TElements for the geometry. More...
class	TTimeHarmonicLinearElasticityElement
	TTimeHarmonicLinearElasticityElement<DIM,NNODE_1D> elements are isoparametric triangular DIM-dimensional TimeHarmonicLinearElasticity elements with NNODE_1D nodal points along each element edge. Inherits from TElement and TimeHarmonicLinearElasticityEquations. More...
class	TubeDomain
	Tube as a domain. The entire domain must be defined by a GeomObject with the following convention: zeta[0] is the coordinate along the centreline, zeta[1] is the theta coordinate around the tube wall and zeta[2] is the radial coordinate. The outer boundary must lie at zeta[2] = 1. More...
class	TubeMesh
	3D tube mesh class. The domain is specified by the GeomObject that identifies the entire volume. Non-refineable base version! More...
class	TUnsteadyHeatElement
	TUnsteadyHeatElement<DIM,NNODE_1D> elements are isoparametric triangular DIM-dimensional UnsteadyHeat elements with NNODE_1D nodal points along each element edge. Inherits from TElement and UnsteadyHeatEquations. More...
class	TwoDAnnularMesh
	2D annular mesh with a unit circle in the middle and a layer of thickness h surrounding it. More...
class	TwoLayerSpineMesh
	Two-layer spine mesh class derived from standard 2D mesh. The mesh contains two layers of spinified fluid elements (of type ELEMENT; e.g SpineElement<QCrouzeixRaviartElement<2>). More...
class	TWomersleyElement
	TWomersleyElement elements are linear/triangular/tetrahedral Womersley elements with isoparametric interpolation for the function. More...
class	UnsteadyHeatEquations
	A class for all isoparametric elements that solve the UnsteadyHeat equations. More...
class	UnsteadyHeatEquationsBase
	Base class so that we don't need to know the dimension just to set the source function! More...
class	UnsteadyHeatFluxElement
	A class for elements that allow the imposition of an applied flux on the boundaries of UnsteadyHeat elements. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. More...
class	UnstructuredTwoDMeshGeometryBase
	Contains functions which define the geometry of the mesh, i.e. regions, boundaries, etc. More...
class	Vector
	A slight extension to the standard template vector class so that we can include "graceful" array range checks if the RANGE_CHECKING flag is set. The generalisation to general allocators is NOT handled here, mainly because we never use it, but also because the intel and gnu compilers have different names for the internal classes, which makes writing code that works for both a pain! More...
class	Vector< bool >
	A Vector of bools cannot be created because the is no compiler-independent implementation of the bit manipulators. Making all the constructors private should lead to compile-time errors. More...
class	VectorMatrix
	VectorMatrix is a generalised, STL-map-based, matrix based on a Vector of Vectors. More...
class	VolumeConstraintBoundingElement
	Base class for interface elements that allow the application of a volume constraint on the region bounded by these elements. The elements must be used together with the associated VolumeConstraintElement which stores the value of the target volume. Common functionality is provided in this base for storing the external "pressure" value that is traded for the volume constraint. More...
class	VolumeConstraintElement
	A class that is used to implement the constraint that the fluid volume in a region bounded by associated FaceElements (attached, e.g., to the mesh boundaries that enclose a bubble) must take a specific value. This GeneralisedElement is used only to store the desired volume and a pointer to the (usually pressure) freedom that must be traded for the volume constraint. More...
class	VorticitySmoother
	Smoother for vorticity in 2D. More...
class	VorticitySmootherElement
	Overloaded element that allows projection of vorticity. More...
class	WarpedCircularDisk
	Warped disk in 3d: zeta[0]=x; zeta[1]=y (so it doesn't have coordinate singularities), with specification of two boundaries (b=0,1) that turn the whole thing into a circular disk. More...
class	WarpedCircularDiskWithAnnularInternalBoundary
	Warped disk in 3d: zeta[0]=x; zeta[1]=y (so it doesn't have coordinate singularities), with specification of two boundaries (b=0,1) that turn the whole thing into a circular disk. In addition has two internal boundaries (b=2,3), a distance h_annulus from the outer edge. Annual (outer) region is region 1. More...
class	WarpedCubeDomain
	Warped cube as domain which is parametrised by a single macro element. More...
class	WomersleyEquations
	A class for all isoparametric elements that solve the Womersley (parallel flow) equations. More...
class	WomersleyImpedanceTubeBase
	Base class for Womersley impedance tube. Allows the computation of the inlet pressure p_in into a uniform tube of specified length that is assumed to convey fully-developed, but time-dependent flow with a presribed instantaneous flow rate, q. Also computes the derivative dp_in/dq required when this is used to determine impedance-type outlet boundary conditions in a Navier-Stokes computation. More...
class	WomersleyMesh
	Mesh of Womersley elements whose topology, nodal position etc. matches that of a given mesh of face elements in the outflow cross-section of a full Navier-Stokes mesh. More...
class	WomersleyOutflowImpedanceTube
	WomersleyImpedanceTube that attaches itself to the outflow of a Navier-Stokes mesh. More...
class	WomersleyProblem
	Womersley problem. More...
class	XdaTetMesh
	Tet mesh made of quadratic (ten node) tets built from xda input file. More...
class	YoungLaplaceContactAngleElement
	A class for elements that allow the imposition of an contact angle bcs for Young Laplace elements. The element geometry is obtained from the FaceGeometry<ELEMENT> policy class. Jacobian is evaluated by finite differencing. More...
class	YoungLaplaceEquations
	A class for all isoparametric elements that solve the YoungLaplace equations. More...
class	Z2ErrorEstimator
	Z2-error-estimator: Elements that can be used with Z2 error estimation should be derived from the base class ElementWithZ2ErrorEstimator and implement its pure virtual member functions to provide the following functionality: More...

Typedefs
typedef void(*	CoordinateMappingFctPt) (const Vector< double > &s, Vector< double > &s_bulk)
	Typedef for the function that translates the face coordinate to the coordinate in the bulk element.
typedef void(*	BulkCoordinateDerivativesFctPt) (const Vector< double > &s, DenseMatrix< double > &ds_bulk_dsface, unsigned &interior_direction)
	Typedef for the function that returns the partial derivative of the local coordinates in the bulk element with respect to the coordinates along the face. In addition this function returns an index of one of the bulk local coordinates that varies away from the edge.

Enumerations
enum	TestStatus { Passed = 0 , Failed = 1 }
enum class	Type { Number , String }
enum	Sample_Point_Container_Type { UseRefineableBinArray = 1 , UseNonRefineableBinArray , UseCGALSamplePointContainer }
	Enumeration to identify type of sample point container. More...

Functions
int	superlu_complex (int *, int *, int *, int *, std::complex< double > *, int *, int *, std::complex< double > *, int *, int *, int *, void *, int *)
std::ostream &	operator<< (std::ostream &out, const DoubleVector &v)
	output operator
bool	ends_with (std::string const &value, std::string const &ending)
std::string	modify_string_inplace (std::string &text, const std::string &symbol, const unsigned &number)
std::vector< std::string >	split_string (const std::string &text)
std::string	lower (const std::string &text)
Type	get_type (const std::string &text)
std::vector< std::string >	gzip_load (const std::string &filename)
std::vector< std::string >	load_file (const std::string &filename)
int	fpdiff (const std::string &filename1, const std::string &filename2, std::ostream &outstream, const double &relative_error, const double &small)
int	fpdiff (const std::string &filename1, const std::string &filename2, const std::string &log_file, const double &relative_error, const double &small)
void	post_midpoint_update (Data *dat_pt, const bool &update_pinned)
	Local (not exported in header) helper function to handle midpoint update on a data object.
std::ostream &	operator<< (std::ostream &stream, LinearAlgebraDistribution &dist)
	output operator
int	superlu (int *, int *, int *, int *, double *, int *, int *, double *, int *, int *, int *, void *, int *)
void	superlu_dist_global_matrix (int opt_flag, int allow_permutations, int n, int nnz, double *values, int *row_index, int *col_start, double *b, int nprow, int npcol, int doc, void **data, int *info, MPI_Comm comm)
void	superlu_dist_distributed_matrix (int opt_flag, int allow_permutations, int n, int nnz_local, int nrow_local, int first_row, double *values, int *col_index, int *row_start, double *b, int nprow, int npcol, int doc, void **data, int *info, MPI_Comm comm)
void	superlu_cr_to_cc (int nrow, int ncol, int nnz, double *cr_values, int *cr_index, int *cr_start, double **cc_values, int **cc_index, int **cc_start)
double	get_lu_factor_memory_usage_in_bytes ()
	Function to calculate the number of bytes used to store the LU factors.
double	get_total_memory_usage_in_bytes ()
	Function to calculate the number of bytes used in calculating and storing the LU factors.
double	get_lu_factor_memory_usage_in_bytes_dist ()
	Function to calculate the number of bytes used to store the LU factors.
double	get_total_memory_usage_in_bytes_dist ()
	Function to calculate the number of bytes used in calculating and storing the LU factors.
std::ostream &	operator<< (std::ostream &out, const Node &nd)
	Node output operator: output equation numbers and values at all times, along with any extra information stored for the timestepper.
void	pause (std::string message)
	Pause and display message.
template<class Target , class Source >
Target	checked_dynamic_cast (Source *x)
	Runtime checked dynamic cast. This is the safe but slightly slower cast. Use it in any of these cases:
template<class Target , class Source >
Target	checked_static_cast (Source *x)
	Checked static cast. Only use this cast if ALL of these are true:
	METIS_API (int) METIS_PartGraphKway(idx_t *
	Metis graph partitioning function.
void	triangulate (char *triswitches, struct oomph::TriangulateIO *in, struct oomph::TriangulateIO *out, struct oomph::TriangulateIO *vorout)

Variables
Nullstream	oomph_nullstream
	Single (global) instantiation of the Nullstream.
OomphInfo	oomph_info
	Single (global) instantiation of the OomphInfo object – this is used throughout the library as a "replacement" for std::cout.
OutputModifier	default_output_modifier
	Single global instatiation of the default output modifier.
MPIOutputModifier	oomph_mpi_output
	Single (global) instantiation of the mpi output modifier.
struct oomph::classcomp	Bottom_left_sorter

Detailed Description

DRAIG: Change all instances of (SPATIAL_DIM) to (DIM-1).

Typedef Documentation

BulkCoordinateDerivativesFctPt

typedef void(* oomph::BulkCoordinateDerivativesFctPt) (const Vector< double > &s, DenseMatrix< double > &ds_bulk_dsface, unsigned &interior_direction)

Typedef for the function that returns the partial derivative of the local coordinates in the bulk element with respect to the coordinates along the face. In addition this function returns an index of one of the bulk local coordinates that varies away from the edge.

Definition at line 1294 of file elements.h.

CoordinateMappingFctPt

typedef void(* oomph::CoordinateMappingFctPt) (const Vector< double > &s, Vector< double > &s_bulk)

Typedef for the function that translates the face coordinate to the coordinate in the bulk element.

Definition at line 1286 of file elements.h.

Enumeration Type Documentation

Sample_Point_Container_Type

enum oomph::Sample_Point_Container_Type

Enumeration to identify type of sample point container.

Enumerator
UseRefineableBinArray
UseNonRefineableBinArray
UseCGALSamplePointContainer

Definition at line 39 of file sample_point_parameters.h.

TestStatus

enum oomph::TestStatus

Enumerator
Passed
Failed

Definition at line 47 of file fpdiff.cc.

Type

enum class oomph::Type

strong

Enumerator
Number
String

Definition at line 57 of file fpdiff.cc.

Function Documentation

checked_dynamic_cast()

template<class Target , class Source >

Target oomph::checked_dynamic_cast ( Source *  x )

inline

Runtime checked dynamic cast. This is the safe but slightly slower cast. Use it in any of these cases:

• You aren't entirely sure the cast is always safe.
• You have strange inheritance structures (e.g. the "Diamond of Death" in element inheritance).
• Efficiency is not critical. Note that if you just want to check if a pointer can be converted to some type you will need to use a plain dynamic_cast. Adapted from polymorphic_cast in boost/cast.hpp, see http://www.boost.org/doc/libs/1_52_0/libs/conversion/cast.htm for more details.

Definition at line 323 of file oomph_utilities.h.

checked_static_cast()

template<class Target , class Source >

Target oomph::checked_static_cast ( Source *  x )

inline

Checked static cast. Only use this cast if ALL of these are true:

• You are sure that the cast will always succeed.
• You aren't using any strange inheritance structures (e.g. the "Diamond of Death" in element inheritance, if you aren't sure just try compiling).
• You need efficiency. Adapted from polymorphic_downcast in boost/cast.hpp, See http://www.boost.org/doc/libs/1_52_0/libs/conversion/cast.htm for more details.

Definition at line 345 of file oomph_utilities.h.

ends_with()

bool oomph::ends_with ( std::string const &  value, std::string const &  ending  )

inline

Definition at line 71 of file fpdiff.cc.

References oomph::FiniteElement::size().

Referenced by gzip_load(), and load_file().

fpdiff() [1/2]

int oomph::fpdiff	(	const std::string &	filename1,
		const std::string &	filename2,
		const std::string &	log_file,
		const double &	relative_error,
		const double &	small
	)

Definition at line 467 of file fpdiff.cc.

References fpdiff().

fpdiff() [2/2]

int oomph::fpdiff	(	const std::string &	filename1,
		const std::string &	filename2,
		std::ostream &	outstream,
		const double &	relative_error,
		const double &	small
	)

Definition at line 210 of file fpdiff.cc.

References get_type(), i, load_file(), lower(), modify_string_inplace(), oomph::FiniteElement::size(), split_string(), and String.

Referenced by fpdiff().

get_lu_factor_memory_usage_in_bytes()

double oomph::get_lu_factor_memory_usage_in_bytes

(

)

Function to calculate the number of bytes used to store the LU factors.

Referenced by oomph::SuperLUSolver::get_memory_usage_for_lu_factors().

get_lu_factor_memory_usage_in_bytes_dist()

double oomph::get_lu_factor_memory_usage_in_bytes_dist

(

)

Function to calculate the number of bytes used to store the LU factors.

Referenced by oomph::SuperLUSolver::get_memory_usage_for_lu_factors().

get_total_memory_usage_in_bytes()

double oomph::get_total_memory_usage_in_bytes

(

)

Function to calculate the number of bytes used in calculating and storing the LU factors.

Referenced by oomph::SuperLUSolver::get_total_needed_memory().

get_total_memory_usage_in_bytes_dist()

double oomph::get_total_memory_usage_in_bytes_dist

(

)

Function to calculate the number of bytes used in calculating and storing the LU factors.

Referenced by oomph::SuperLUSolver::get_total_needed_memory().

get_type()

Type oomph::get_type

(

const std::string &

text

)

Definition at line 143 of file fpdiff.cc.

References Number, and String.

Referenced by fpdiff().

gzip_load()

std::vector< std::string > oomph::gzip_load

(

const std::string &

filename

)

Definition at line 161 of file fpdiff.cc.

References ends_with(), and oomph::GZipReader::read_all().

Referenced by load_file().

load_file()

std::vector< std::string > oomph::load_file

(

const std::string &

filename

)

Definition at line 179 of file fpdiff.cc.

References ends_with(), and gzip_load().

Referenced by fpdiff().

lower()

std::string oomph::lower ( const std::string &  text )

inline

Definition at line 123 of file fpdiff.cc.

Referenced by oomph::HypreHelpers::create_HYPRE_Matrix(), oomph::HypreHelpers::create_HYPRE_Vector(), oomph::HypreHelpers::create_HYPRE_Vector(), fpdiff(), oomph::Gauss_Rescaled< DIM, NPTS_1D >::Gauss_Rescaled(), and oomph::DenseComplexMatrix::ludecompose().

METIS_API()

oomph::METIS_API

(

int

)

Metis graph partitioning function.

modify_string_inplace()

std::string oomph::modify_string_inplace ( std::string &  text, const std::string &  symbol, const unsigned &  number  )

inline

Definition at line 88 of file fpdiff.cc.

References i.

Referenced by fpdiff().

operator<<() [1/3]

std::ostream & oomph::operator<<	(	std::ostream &	out,
		const DoubleVector &	v
	)

output operator

Ouput operator for DoubleVector.

Definition at line 949 of file double_vector.cc.

operator<<() [2/3]

std::ostream & oomph::operator<<	(	std::ostream &	out,
		const Node &	nd
	)

Node output operator: output equation numbers and values at all times, along with any extra information stored for the timestepper.

Output operator: output location and all values at all times, along with any extra information stored for the timestepper.

Definition at line 373 of file nodes.cc.

operator<<() [3/3]

std::ostream & oomph::operator<<	(	std::ostream &	stream,
		LinearAlgebraDistribution &	dist
	)

output operator

<< operator

Definition at line 318 of file linear_algebra_distribution.cc.

pause()

void oomph::pause

(

std::string

message

)

Pause and display message.

Pause and dump out message.

Definition at line 1273 of file oomph_utilities.cc.

References oomph_info, and oomph::PauseFlags::PauseFlag.

Referenced by oomph::OcTree::doc_face_neighbours(), oomph::OcTree::doc_true_edge_neighbours(), oomph::TreeBasedRefineableMeshBase::refine_as_in_reference_mesh(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_lists(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_maps(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_two_arrays(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_two_vectors(), and oomph::Problem::sparse_assemble_row_or_column_compressed_with_vectors_of_pairs().

post_midpoint_update()

void oomph::post_midpoint_update	(	Data *	dat_pt,
		const bool &	update_pinned
	)

Local (not exported in header) helper function to handle midpoint update on a data object.

Definition at line 186 of file implicit_midpoint_rule.cc.

References oomph::GeneralisedElement::eqn_number().

Referenced by oomph::IMRByBDF::actions_after_timestep().

split_string()

std::vector< std::string > oomph::split_string ( const std::string &  text )

inline

Definition at line 105 of file fpdiff.cc.

Referenced by fpdiff().

superlu()

int oomph::superlu	(	int *	,
		int *	,
		int *	,
		int *	,
		double *	,
		int *	,
		int *	,
		double *	,
		int *	,
		int *	,
		int *	,
		void *	,
		int *
	)

Referenced by oomph::SuperLUSolver::backsub_serial(), oomph::SuperLUSolver::backsub_transpose_serial(), oomph::SuperLUSolver::clean_up_memory(), and oomph::SuperLUSolver::factorise_serial().

superlu_complex()

int oomph::superlu_complex	(	int *	,
		int *	,
		int *	,
		int *	,
		std::complex< double > *	,
		int *	,
		int *	,
		std::complex< double > *	,
		int *	,
		int *	,
		int *	,
		void *	,
		int *
	)

Referenced by oomph::CRComplexMatrix::clean_up_memory(), oomph::CCComplexMatrix::clean_up_memory(), oomph::CRComplexMatrix::lubksub(), oomph::CCComplexMatrix::lubksub(), oomph::CRComplexMatrix::ludecompose(), and oomph::CCComplexMatrix::ludecompose().

superlu_cr_to_cc()

void oomph::superlu_cr_to_cc	(	int	nrow,
		int	ncol,
		int	nnz,
		double *	cr_values,
		int *	cr_index,
		int *	cr_start,
		double **	cc_values,
		int **	cc_index,
		int **	cc_start
	)

Referenced by oomph::SuperLUSolver::factorise_distributed().

superlu_dist_distributed_matrix()

void oomph::superlu_dist_distributed_matrix	(	int	opt_flag,
		int	allow_permutations,
		int	n,
		int	nnz_local,
		int	nrow_local,
		int	first_row,
		double *	values,
		int *	col_index,
		int *	row_start,
		double *	b,
		int	nprow,
		int	npcol,
		int	doc,
		void **	data,
		int *	info,
		MPI_Comm	comm
	)

Referenced by oomph::SuperLUSolver::backsub_distributed(), oomph::SuperLUSolver::clean_up_memory(), and oomph::SuperLUSolver::factorise_distributed().

superlu_dist_global_matrix()

void oomph::superlu_dist_global_matrix	(	int	opt_flag,
		int	allow_permutations,
		int	n,
		int	nnz,
		double *	values,
		int *	row_index,
		int *	col_start,
		double *	b,
		int	nprow,
		int	npcol,
		int	doc,
		void **	data,
		int *	info,
		MPI_Comm	comm
	)

Referenced by oomph::SuperLUSolver::backsub_distributed(), oomph::SuperLUSolver::clean_up_memory(), and oomph::SuperLUSolver::factorise_distributed().

triangulate()

void oomph::triangulate	(	char *	triswitches,
		struct oomph::TriangulateIO *	in,
		struct oomph::TriangulateIO *	out,
		struct oomph::TriangulateIO *	vorout
	)

Referenced by oomph::QuadFromTriangleMesh< ELEMENT >::generic_constructor(), oomph::TriangleMesh< ELEMENT >::generic_constructor(), oomph::RefineableTriangleMesh< ELEMENT >::RefineableTriangleMesh(), and oomph::TriangleMesh< ELEMENT >::TriangleMesh().

Variable Documentation

Bottom_left_sorter

struct oomph::classcomp oomph::Bottom_left_sorter

Referenced by oomph::RefineableTriangleMesh< ELEMENT >::sort_nodes_on_shared_boundaries().

default_output_modifier

OutputModifier oomph::default_output_modifier

Single global instatiation of the default output modifier.

Definition at line 332 of file oomph_definitions.cc.

Referenced by oomph::OomphInfo::OomphInfo().

oomph_info

OomphInfo oomph::oomph_info

Single (global) instantiation of the OomphInfo object – this is used throughout the library as a "replacement" for std::cout.

Definition at line 326 of file oomph_definitions.cc.

Referenced by oomph::BiharmonicProblem< DIM >::actions_before_newton_solve(), oomph::BiharmonicFluidProblem< DIM >::actions_before_newton_solve(), oomph::NonLinearElasticitySmoothMesh< ELEMENT >::actions_before_newton_solve(), oomph::RefineableGmshTetMesh< ELEMENT >::adapt(), oomph::RefineableTetgenMesh< ELEMENT >::adapt(), oomph::RefineableTriangleMesh< ELEMENT >::adapt(), oomph::TreeBasedRefineableMeshBase::adapt(), oomph::Problem::adapt(), oomph::Problem::adapt_based_on_error_estimates(), oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), oomph::Problem::adaptive_unsteady_newton_solve(), oomph::RefineableTriangleMesh< ELEMENT >::add_element_load_balance_helper(), oomph::GeneralisedElement::add_external_data(), oomph::Multi_domain_functions::add_external_halo_master_node_helper(), oomph::Missing_masters_functions::add_external_halo_master_node_helper(), oomph::Multi_domain_functions::add_external_halo_node_helper(), oomph::Missing_masters_functions::add_external_halo_node_helper(), oomph::RefineableTriangleMesh< ELEMENT >::add_halo_element_helper(), oomph::RefineableTriangleMesh< ELEMENT >::add_halo_node_helper(), oomph::GeneralisedElement::add_internal_data(), oomph::RefineableTriangleMesh< ELEMENT >::add_received_node_load_balance_helper(), oomph::Problem::add_time_stepper_pt(), oomph::TreeBasedRefineableMesh< ELEMENT >::additional_synchronise_hanging_nodes(), oomph::Problem::arc_length_step_solve(), oomph::Problem::arc_length_step_solve(), oomph::Problem::arc_length_step_solve_helper(), oomph::TetMeshBase::assess_mesh_quality(), oomph::Problem::assign_eqn_numbers(), oomph::Multi_domain_functions::aux_setup_multi_domain_interaction(), oomph::MumpsSolver::backsub(), oomph::Problem::bifurcation_adapt_helper(), oomph::BlackBoxFDNewtonSolver::black_box_fd_newton_solve(), oomph::HelmholtzMGPreconditioner< DIM >::block_preconditioner_self_test(), oomph::BrethertonSpineMesh< ELEMENT, INTERFACE_ELEMENT >::BrethertonSpineMesh(), oomph::QSpectralElement< 3, NNODE_1D >::build_face_element(), oomph::MeshAsGeomObject::build_it(), oomph::ExtrudedCubeMeshFromQuadMesh< ELEMENT >::build_mesh(), oomph::FishMesh< ELEMENT >::build_mesh(), oomph::TriangleMesh< ELEMENT >::build_triangulateio(), oomph::CassonTanMilRegWithBlendingConstitutiveEquation< DIM >::CassonTanMilRegWithBlendingConstitutiveEquation(), oomph::BinaryTreeForest::check_all_neighbours(), oomph::OcTreeForest::check_all_neighbours(), oomph::QuadTreeForest::check_all_neighbours(), oomph::Mesh::check_for_repeated_nodes(), oomph::Problem::check_halo_schemes(), oomph::Mesh::check_halo_schemes(), oomph::HypreHelpers::check_HYPRE_error_flag(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::check_integrity(), oomph::RefineableQElement< 3 >::check_integrity(), oomph::RefineableQElement< 1 >::check_integrity(), oomph::RefineableQElement< 2 >::check_integrity(), oomph::Mesh::classify_halo_and_haloed_nodes(), oomph::TreeBasedRefineableMeshBase::classify_halo_and_haloed_nodes(), oomph::TreeBasedRefineableMeshBase::complete_hanging_nodes(), oomph::ComplexDampedJacobi< MATRIX >::complex_solve_helper(), oomph::ComplexGMRES< MATRIX >::complex_solve_helper(), oomph::RefineableTriangleMesh< ELEMENT >::compute_area_target(), oomph::CRDoubleMatrixHelpers::concatenate(), oomph::Multi_domain_functions::construct_new_external_halo_master_node_helper(), oomph::Missing_masters_functions::construct_new_external_halo_master_node_helper(), oomph::Multi_domain_functions::construct_new_external_halo_node_helper(), oomph::Missing_masters_functions::construct_new_external_halo_node_helper(), oomph::RefineableTriangleMesh< ELEMENT >::construct_new_halo_node_helper(), oomph::RefineableTriangleMesh< ELEMENT >::construct_new_node_load_balance_helper(), oomph::Problem::copy(), oomph::RefineableTriangleMesh< ELEMENT >::create_element_load_balance_helper(), oomph::Multi_domain_functions::create_external_halo_elements(), oomph::RefineableTriangleMesh< ELEMENT >::create_halo_element(), oomph::GmshTetScaffoldMesh::create_mesh_from_msh_file(), oomph::RefineableTriangleMesh< ELEMENT >::create_new_shared_boundaries(), oomph::FiniteElement::d_dshape_eulerian_dnodal_coordinates_templated_helper(), oomph::Problem::debug_hook_fct(), oomph::MGSolver< DIM >::disable_output(), oomph::HelmholtzMGPreconditioner< DIM >::disable_output(), oomph::Problem::distribute(), oomph::Mesh::distribute(), oomph::FiniteElement::dJ_eulerian_dnodal_coordinates_templated_helper(), oomph::LeakCheckNames::doc(), oomph::CommandLineArgs::doc_available_flags(), oomph::Mesh::doc_boundary_coordinates(), oomph::Problem::doc_errors(), oomph::HypreInterface::doc_hypre_parameters(), oomph::Mesh::doc_shared_nodes(), oomph::NonLinearElasticitySmoothMesh< ELEMENT >::doc_solution(), oomph::BiharmonicProblem< DIM >::doc_solution(), oomph::BiharmonicFluidProblem< DIM >::doc_solution(), oomph::CommandLineArgs::doc_specified_flags(), oomph::BlockPreconditioner< MATRIX >::document(), oomph::Problem::doubly_adaptive_unsteady_newton_solve_helper(), oomph::PRefineableQElement< 1, INITIAL_NNODE_1D >::dshape_local(), oomph::CRDoubleMatrix::entries_are_sorted(), oomph::MumpsSolver::factorise(), oomph::SolidFiniteElement::fill_in_generic_jacobian_for_solid_ic(), oomph::BrethertonSpineMesh< ELEMENT, INTERFACE_ELEMENT >::find_distance_to_free_surface(), oomph::MGSolver< DIM >::full_setup(), oomph::HelmholtzMGPreconditioner< DIM >::full_setup(), oomph::FullCircleMesh< ELEMENT >::FullCircleMesh(), oomph::GeompackQuadScaffoldMesh::GeompackQuadScaffoldMesh(), oomph::Problem::get_all_error_estimates(), oomph::KirchhoffLoveShellEquations::get_energy(), oomph::Problem::get_inverse_mass_matrix_times_residuals(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::get_pressure_advection_diffusion_jacobian(), oomph::VorticitySmootherElement< ELEMENT >::get_raw_velocity_deriv(), oomph::VorticitySmootherElement< ELEMENT >::get_raw_vorticity_deriv(), oomph::VorticitySmootherElement< ELEMENT >::get_raw_vorticity_second_deriv(), oomph::VorticitySmootherElement< ELEMENT >::get_raw_vorticity_third_deriv(), oomph::VorticitySmoother< ELEMENT >::get_recovered_vorticity_in_patch(), oomph::Missing_masters_functions::get_required_master_nodal_information_helper(), oomph::Problem::globally_convergent_line_search(), oomph::GmshTetScaffoldMesh::GmshTetScaffoldMesh(), oomph::HerschelBulkleyTanMilRegConstitutiveEquation< DIM >::HerschelBulkleyTanMilRegConstitutiveEquation(), oomph::HerschelBulkleyTanMilRegWithBlendingConstitutiveEquation< DIM >::HerschelBulkleyTanMilRegWithBlendingConstitutiveEquation(), oomph::HypreInterface::hypre_matrix_setup(), oomph::HypreInterface::hypre_solve(), oomph::HypreInterface::hypre_solver_setup(), oomph::MPI_Helpers::init(), oomph::FiniteElement::invert_jacobian(), oomph::FiniteElement::J_eulerian(), oomph::FiniteElement::J_eulerian_at_knot(), oomph::RefineableTriangleMesh< ELEMENT >::load_balance(), oomph::Problem::load_balance(), oomph::PRefineableQElement< 1, INITIAL_NNODE_1D >::local_coordinate_of_node(), oomph::FiniteElement::locate_zeta(), oomph::MGSolver< DIM >::mg_solve(), oomph::HelmholtzMGPreconditioner< DIM >::mg_solve(), oomph::Problem::newton_solve(), oomph::Problem::newton_solve(), oomph::Problem::newton_solve_continuation(), oomph::Mesh::node_update(), oomph::DGEulerFaceElement< ELEMENT >::numerical_flux(), oomph::ObsoleteCode::obsolete(), oomph::ObsoleteCode::obsolete(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::oc_hang_helper(), oomph::NonLinearElasticitySmoothMesh< ELEMENT >::operator()(), oomph::LinearElasticitySmoothMesh< LINEAR_ELASTICITY_ELEMENT >::operator()(), oomph::PoissonSmoothMesh< POISSON_ELEMENT >::operator()(), oomph::CommandLineArgs::output(), oomph::Mesh::output(), oomph::Mesh::output(), RefineableBin::output(), oomph::Mesh::output(), oomph::Mesh::output(), oomph::ClampedHermiteShellBoundaryConditionElement::output(), RefineableBin::output_bin_vertices(), oomph::Mesh::output_fct(), oomph::Mesh::output_fct(), oomph::TreeBasedRefineableMeshBase::p_adapt(), oomph::Problem::p_adapt(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::Problem::p_refine_selected_elements(), oomph::Problem::p_refine_selected_elements(), oomph::Problem::p_refine_selected_elements(), oomph::Problem::p_refine_selected_elements(), oomph::Problem::p_refine_selected_elements(), oomph::Problem::p_refine_selected_elements(), oomph::Problem::p_refine_uniformly(), oomph::Problem::p_refine_uniformly_aux(), oomph::Problem::p_unrefine_uniformly(), oomph::Problem::p_unrefine_uniformly(), oomph::Problem::parallel_sparse_assemble(), oomph::CommandLineArgs::parse_and_assign(), oomph::METIS::partition_distributed_mesh(), oomph::Problem::partition_global_mesh(), oomph::METIS::partition_mesh(), pause(), oomph::StorableShapeElementBase::pre_compute_d2shape_eulerian_at_knots(), oomph::StorableShapeSolidElementBase::pre_compute_d2shape_lagrangian_at_knots(), oomph::StorableShapeElementBase::pre_compute_d2shape_local_at_knots(), oomph::BlockDiagonalPreconditioner< MATRIX >::preconditioner_solve(), oomph::HelmholtzMGPreconditioner< DIM >::preconditioner_solve(), oomph::PressureBasedSolidLSCPreconditioner::preconditioner_solve(), oomph::BandedBlockTriangularPreconditioner< MATRIX >::preconditioner_solve(), oomph::GMRESBlockPreconditioner::preconditioner_solve(), oomph::MGPreconditioner< DIM >::preconditioner_solve(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project(), oomph::Problem::prune_halo_elements_and_nodes(), oomph::Mesh::prune_halo_elements_and_nodes(), oomph::PseudoBucklingRing::PseudoBucklingRing(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::quad_hang_helper(), oomph::QuarterTubeMesh< ELEMENT >::QuarterTubeMesh(), oomph::Problem::read(), oomph::Problem::recompute_load_balanced_assembly(), oomph::VorticitySmoother< ELEMENT >::recover_vorticity(), oomph::Multi_domain_functions::recursively_add_masters_of_external_halo_node_to_storage(), oomph::Missing_masters_functions::recursively_add_masters_of_external_halo_node_to_storage(), oomph::TreeBasedRefineableMeshBase::refine_as_in_reference_mesh(), oomph::Problem::refine_selected_elements(), oomph::Problem::refine_selected_elements(), oomph::Problem::refine_selected_elements(), oomph::Problem::refine_selected_elements(), oomph::Problem::refine_selected_elements(), oomph::Problem::refine_selected_elements(), oomph::Problem::refine_uniformly(), oomph::Problem::refine_uniformly_aux(), oomph::RefineableFullCircleMesh< ELEMENT >::RefineableFullCircleMesh(), oomph::RefineableQuarterTubeMesh< ELEMENT >::RefineableQuarterTubeMesh(), oomph::RefineableTubeMesh< ELEMENT >::RefineableTubeMesh(), oomph::TriangleMeshBase::remesh_from_triangulateio(), oomph::Problem::remove_duplicate_data(), oomph::HSL_MA42::reorder_elements(), oomph::HyprePreconditioner::report_cumulative_solve_times(), oomph::DGFaceElement::report_info(), oomph::BrethertonSpineMesh< ELEMENT, INTERFACE_ELEMENT >::reposition_spines(), oomph::RefineableTriangleMesh< ELEMENT >::reset_halo_haloed_scheme(), oomph::RefineableTriangleMesh< ELEMENT >::reset_halo_haloed_scheme_helper(), oomph::Mesh::resize_halo_nodes(), oomph::SuperLUSolver::resolve(), oomph::MumpsSolver::resolve(), oomph::TrilinosAztecOOSolver::resolve(), oomph::SuperLUSolver::resolve_transpose(), oomph::VorticitySmootherElement< ELEMENT >::scalar_name_paraview(), oomph::SegregatableFSIProblem::segregated_solve(), oomph::AlgebraicNode::self_test(), oomph::AlgebraicMesh::self_test(), oomph::BinaryTree::self_test(), oomph::BinaryTreeForest::self_test(), oomph::GeneralisedElement::self_test(), oomph::MGSolver< DIM >::self_test(), oomph::Mesh::self_test(), oomph::Data::self_test(), oomph::OcTree::self_test(), oomph::OcTreeForest::self_test(), oomph::Problem::self_test(), oomph::QuadTree::self_test(), oomph::QuadTreeForest::self_test(), oomph::RefineableTriangleMesh< ELEMENT >::send_and_receive_elements_nodes_info(), oomph::Multi_domain_functions::send_and_receive_located_info(), oomph::Problem::set_default_first_and_last_element_for_assembly(), oomph::Biharmonic_schur_complement_Hypre_defaults::set_defaults(), oomph::Problem::set_explicit_time_stepper_pt(), oomph::SolidICProblem::set_newmark_initial_condition_consistently(), oomph::SolidICProblem::set_newmark_initial_condition_directly(), oomph::SolidICProblem::set_static_initial_condition(), oomph::BiharmonicPreconditioner::setup(), oomph::BlockDiagonalPreconditioner< MATRIX >::setup(), oomph::BlockTriangularPreconditioner< MATRIX >::setup(), oomph::MGPreconditioner< DIM >::setup(), oomph::HyprePreconditioner::setup(), oomph::MumpsPreconditioner::setup(), oomph::SuperLUPreconditioner::setup(), oomph::FSIPreconditioner::setup(), oomph::NavierStokesSchurComplementPreconditioner::setup(), oomph::HelmholtzMGPreconditioner< DIM >::setup(), oomph::PressureBasedSolidLSCPreconditioner::setup(), oomph::ExactDGPBlockPreconditioner< MATRIX >::setup(), oomph::BandedBlockTriangularPreconditioner< MATRIX >::setup(), oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::setup(), oomph::GMRESBlockPreconditioner::setup(), oomph::MatrixVectorProduct::setup(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::setup(), oomph::LineVisualiser::setup(), oomph::HelmholtzMGPreconditioner< DIM >::setup_coarsest_level_structures(), oomph::LineVisualiser::setup_from_file(), oomph::TR::setup_initial_derivative(), oomph::MGSolver< DIM >::setup_mg_hierarchy(), oomph::HelmholtzMGPreconditioner< DIM >::setup_mg_hierarchy(), oomph::MGSolver< DIM >::setup_mg_structures(), oomph::HelmholtzMGPreconditioner< DIM >::setup_mg_structures(), oomph::VorticitySmoother< ELEMENT >::setup_patches(), oomph::Z2ErrorEstimator::setup_patches(), oomph::SolidICProblem::setup_problem(), oomph::SegregatableFSIProblem::setup_segregated_solver(), oomph::Mesh::setup_shared_node_scheme(), oomph::MGSolver< DIM >::setup_smoothers(), oomph::HelmholtzMGPreconditioner< DIM >::setup_smoothers(), oomph::OcTree::setup_static_data(), oomph::MGSolver< DIM >::setup_transfer_matrices(), oomph::HelmholtzMGPreconditioner< DIM >::setup_transfer_matrices(), oomph::TrilinosMLPreconditioner::setup_trilinos_preconditioner(), oomph::PRefineableQElement< 1, INITIAL_NNODE_1D >::shape(), oomph::SimpleCubicTetMesh< ELEMENT >::SimpleCubicTetMesh(), oomph::SiskoTanMilRegWithBlendingConstitutiveEquation< DIM >::SiskoTanMilRegWithBlendingConstitutiveEquation(), oomph::RefineableTetgenMesh< ELEMENT >::snap_nodes_onto_boundary(), oomph::TetMeshBase::snap_nodes_onto_geometric_objects(), oomph::DenseLU::solve(), oomph::SuperLUSolver::solve(), oomph::MumpsSolver::solve(), oomph::TrilinosAztecOOSolver::solve(), oomph::DenseLU::solve(), oomph::HSL_MA42::solve(), oomph::MGSolver< DIM >::solve(), oomph::CG< MATRIX >::solve(), oomph::BiCGStab< MATRIX >::solve(), oomph::GS< MATRIX >::solve(), oomph::GS< CRDoubleMatrix >::solve(), oomph::DampedJacobi< MATRIX >::solve(), oomph::GMRES< MATRIX >::solve(), oomph::AugmentedProblemGMRES::solve(), oomph::DenseLU::solve(), oomph::FD_LU::solve(), oomph::SuperLUSolver::solve(), oomph::MumpsSolver::solve(), oomph::HelmholtzGMRESMG< MATRIX >::solve(), oomph::HelmholtzFGMRESMG< MATRIX >::solve(), oomph::HypreSolver::solve(), oomph::TrilinosAztecOOSolver::solve(), oomph::ANASAZI::solve_eigenproblem(), oomph::CG< MATRIX >::solve_helper(), oomph::BiCGStab< MATRIX >::solve_helper(), oomph::GS< MATRIX >::solve_helper(), oomph::GS< CRDoubleMatrix >::solve_helper(), oomph::DampedJacobi< MATRIX >::solve_helper(), oomph::GMRES< MATRIX >::solve_helper(), oomph::AugmentedProblemGMRES::solve_helper(), oomph::HelmholtzGMRESMG< MATRIX >::solve_helper(), oomph::HelmholtzFGMRESMG< MATRIX >::solve_helper(), oomph::SuperLUSolver::solve_transpose(), oomph::SuperLUSolver::solve_transpose(), oomph::TrilinosAztecOOSolver::solve_using_AztecOO(), oomph::TrilinosAztecOOSolver::solver_setup(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_lists(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_maps(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_two_arrays(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_two_vectors(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_vectors_of_pairs(), oomph::TetMeshBase::split_elements_in_corners(), oomph::Problem::steady_newton_solve(), oomph::SegregatableFSIProblem::steady_segregated_solve(), oomph::Problem::synchronise_eqn_numbers(), oomph::TreeBasedRefineableMeshBase::synchronise_hanging_nodes(), oomph::TreeBasedRefineableMeshBase::synchronise_nonhanging_nodes(), oomph::Mesh::synchronise_shared_nodes(), oomph::TubeMesh< ELEMENT >::TubeMesh(), oomph::Problem::unrefine_uniformly(), oomph::Problem::unrefine_uniformly(), oomph::Problem::unsteady_newton_solve(), oomph::Problem::unsteady_newton_solve(), oomph::SegregatableFSIProblem::unsteady_segregated_solve(), oomph::RefineableTetgenMesh< ELEMENT >::update_faceted_surface_using_face_mesh(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::validate(), oomph::WomersleyProblem< ELEMENT, DIM >::WomersleyProblem(), oomph::WomersleyProblem< ELEMENT, DIM >::WomersleyProblem(), and oomph::HyprePreconditioner::~HyprePreconditioner().

oomph_mpi_output

MPIOutputModifier oomph::oomph_mpi_output

Single (global) instantiation of the mpi output modifier.

Definition at line 955 of file oomph_utilities.cc.

Referenced by oomph::MPI_Helpers::init().

oomph_nullstream

Nullstream oomph::oomph_nullstream

Single (global) instantiation of the Nullstream.

Definition at line 320 of file oomph_definitions.cc.

Referenced by oomph::MGSolver< DIM >::disable_output(), oomph::HelmholtzMGPreconditioner< DIM >::disable_output(), oomph::OomphInfo::operator<<(), oomph::BlockDiagonalPreconditioner< MATRIX >::setup(), oomph::BlockTriangularPreconditioner< MATRIX >::setup(), oomph::ExactDGPBlockPreconditioner< MATRIX >::setup(), oomph::BandedBlockTriangularPreconditioner< MATRIX >::setup(), oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::setup(), and oomph::GMRESBlockPreconditioner::setup().