Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
oomph Namespace Reference

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...

Namespaces

 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.
 
 AxisymmetricLinearElasticityTractionElementHelper
 Namespace containing the zero traction function for axisymmetric linear elasticity traction elements.
 
 AxisymmetricNavierStokesTractionElementHelper
 Namespace containing the zero traction function for axisymmetric Navier Stokes traction elements.
 
 AxisymmetricPoroelasticityTractionElementHelper
 Namespace containing the zero pressure function for Darcy pressure elements.
 
 Biharmonic_schur_complement_Hypre_defaults
 
 BinaryTreeNames
 Namespace for BinaryTree directions.
 
 BlackBoxFDNewtonSolver
 Namespace for black-box FD Newton solver.
 
 BrickFromTetMeshHelper
 Helper namespace for generation of brick from tet mesh.
 
 BrokenCopy
 Namespace for error messages for broken copy constructors and assignment operators.
 
 CommandLineArgs
 Namespace for command line arguments.
 
 CRDoubleMatrixHelpers
 Namespace for helper functions for CRDoubleMatrices.
 
 CumulativeTimings
 /////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////
 
 DarcyFaceElementHelper
 Namespace containing the zero pressure function for Darcy pressure elements.
 
 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.
 
 DoubleVectorHelpers
 Namespace for helper functions for DoubleVectors.
 
 ElementGeometry
 Enumeration a finite element's geometry "type". Either "Q" (square, cubeoid like) or "T" (triangle, tetrahedron).
 
 FSI_functions
 Namespace for "global" FSI functions.
 
 Global_output_stream
 ///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
 
 Global_string_for_annotation
 ///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
 
 Global_timings
 //////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
 
 Global_unsigned
 ///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
 
 Hankel_functions_for_helmholtz_problem
 ////////////////////////////////////////////////////////////////////
 
 Helper_namespace_for_mesh_smoothing
 Helper namespace.
 
 Hypre_default_settings
 ///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
 
 HypreHelpers
 /////////////////////////////////////////////////////////////////////
 
 HypreSubsidiaryPreconditionerHelper
 Helper method for the block diagonal F block preconditioner to allow hypre to be used as a subsidiary block preconditioner.
 
 Lagrange_Enforced_Flow_Preconditioner_Subsidiary_Operator_Helper
 Namespace for subsidiary preconditioner creation helper functions.
 
 LeakCheckNames
 Namespace for leak check: Keep a running count of all instantiated objects – add your own if you want to...
 
 Legendre_functions_helper
 Helper namespace for functions required for Helmholtz computations.
 
 LinearAlgebraDistributionHelpers
 Namespace for helper functions for LinearAlgebraDistributions.
 
 LinearElasticityTractionElementHelper
 Namespace containing the zero traction function for linear elasticity traction elements.
 
 LinearisedAxisymPoroelasticBJS_FSIHelper
 Namespace containing the default Strouhal number of axisymmetric linearised poroelastic FSI.
 
 LinearisedFSIAxisymmetricNStNoSlipBCHelper
 ////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
 
 Locate_zeta_helpers
 Helper namespace for tolerances, number of iterations, etc used in the locate_zeta function in FiniteElement.
 
 MathematicalConstants
 Namespace for mathematical constants.
 
 MemoryUsage
 ///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
 
 MeshAsGeomObject_Helper
 ///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
 
 MeshChecker
 //////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
 
 MeshExtrusionHelpers
 
 METIS
 Namespace for METIS graph partitioning routines.
 
 Missing_masters_functions
 
 Multi_domain_functions
 
 MultiDomainBoussinesqHelper
 Namespace for default parameters in multi-domain Boussinesq.
 
 NodeOrdering
 ///////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////
 
 ObsoleteCode
 Namespace for flagging up obsolete parts of the code.
 
 OcTreeNames
 
 OneDimDiscontinuousGalerkin
 One dimensional shape functions and derivatives. Empty – simply establishes the template parameters.
 
 OneDimDiscontinuousGalerkinMixedOrderBasis
 One dimensional shape functions and derivatives. Empty – simply establishes the template parameters.
 
 OneDimDiscontinuousGalerkinMixedOrderTest
 One dimensional shape functions and derivatives. Empty – simply establishes the template parameters.
 
 OneDimHermite
 One Dimensional Hermite shape functions.
 
 OneDimLagrange
 
 Orthpoly
 
 ParaviewHelper
 //////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
 
 PauseFlags
 ////////////////////////////////////////////////////////////////////////
 
 PMLTimeHarmonicLinearElasticityTractionElementHelper
 Namespace containing the zero traction function for linear elasticity traction elements.
 
 PoroelasticityFaceElementHelper
 Namespace containing the zero pressure function for Darcy pressure elements.
 
 PreconditionerCreationFunctions
 
 PressureAdvectionDiffusionValidation
 //////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
 
 Pseudo_Elastic_Preconditioner_Subsidiary_Operator_Helper
 Functions to create instances of optimal subsidiary operators for the PseudoElasticPreconditioner.
 
 PseudoSolidHelper
 Helper namespace for pseudo-elastic elements.
 
 QElement1BulkCoordinateDerivatives
 Namespace for helper functions that calculate derivatives of the local coordinates in the bulk elements wrt the local coordinates in the face element.
 
 QElement1FaceToBulkCoordinates
 Namespace for helper functions that return the local coordinates in the bulk elements.
 
 QElement2BulkCoordinateDerivatives
 Namespace for helper functions that calculate derivatives of the local coordinates in the bulk elements wrt the local coordinates in the face element.
 
 QElement2FaceToBulkCoordinates
 Namespace for the functions that translate local face coordinates to the coordinates in the bulk element.
 
 QElement3BulkCoordinateDerivatives
 Namespace for helper functions that calculate derivatives of the local coordinates in the bulk elements wrt the local coordinates in the face element.
 
 QElement3FaceToBulkCoordinates
 Namespace for the functions that translate local face coordinates to the coordinates in the bulk element.
 
 QuadTreeNames
 Namespace for QuadTree directions.
 
 RRR
 
 SecondInvariantHelper
 Helper namespace containing function that computes second invariant of tensor.
 
 SolidHelpers
 /////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////
 
 SolidTractionElementHelper
 Namespace containing the zero traction function for solid traction elements.
 
 StringConversion
 Conversion functions for easily making strings (e.g. for filenames - to avoid stack smashing problems with cstrings and long filenames).
 
 TecplotNames
 Namespace for tecplot stuff.
 
 TElement1BulkCoordinateDerivatives
 Namespace for helper functions that calculate derivatives of the local coordinates in the bulk elements wrt the local coordinates in the face element.
 
 TElement1FaceToBulkCoordinates
 Namespace for helper functions that return the local coordinates in the bulk elements.
 
 TElement2BulkCoordinateDerivatives
 Namespace for helper functions that calculate derivatives of the local coordinates in the bulk elements wrt the local coordinates in the face element.
 
 TElement2FaceToBulkCoordinates
 Namespace for the functions that translate local face coordinates to the coordinates in the bulk element.
 
 TElement3FaceToBulkCoordinates
 Namespace for the functions that translate local face coordinates to the coordinates in the bulk element.
 
 TerminateHelper
 ////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////
 
 TimeHarmonicFourierDecomposedLinearElasticityTractionElementHelper
 Namespace containing the zero traction function for time-harmonic Fourier decomposed linear elasticity traction elements.
 
 TimeHarmonicLinearElasticityTractionElementHelper
 Namespace containing the zero traction function for linear elasticity traction elements.
 
 TimingHelpers
 //////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
 
 ToleranceForFourierDecomposedHelmholtzOuterBoundary
 ////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////
 
 ToleranceForHelmholtzOuterBoundary
 ////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////
 
 ToleranceForVertexMismatchInPolygons
 ///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
 
 TriangleBoundaryHelper
 /////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
 
 TriangleHelper
 Helper namespace for triangle meshes.
 
 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.
 
 TwoDimensionalPMLHelper
 Namespace with functions that allow the construction of PML layers on axis aligned boundaries.
 
 TypeNames
 
 VectorHelpers
 Namespace for helper functions for Vector<double>
 
 VorticityRecoveryHelpers
 Namespace with helper functions for (2D) vorticity (and derivatives) recovery.
 

Classes

class  AdvectionDiffusionEquations
 A class for all elements that solve the Advection Diffusion equations using isoparametric elements. More...
 
class  QAdvectionDiffusionElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QAdvectionDiffusionElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QAdvectionDiffusionElement< 1, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  AdvectionDiffusionFluxElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  GeneralisedAdvectionDiffusionEquations
 A class for all elements that solve the Advection Diffusion equations in conservative form using isoparametric elements. More...
 
class  QGeneralisedAdvectionDiffusionElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QGeneralisedAdvectionDiffusionElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QGeneralisedAdvectionDiffusionElement< 1, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  RefineableQAdvectionDiffusionElement
 Refineable version of QAdvectionDiffusionElement. Inherit from the standard QAdvectionDiffusionElement and the appropriate refineable geometric element and the refineable equations. More...
 
class  FaceGeometry< RefineableQAdvectionDiffusionElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  RefineableQGeneralisedAdvectionDiffusionElement
 Refineable version of QGeneralisedAdvectionDiffusionElement. Inherit from the standard QGeneralisedAdvectionDiffusionElement and the appropriate refineable geometric element and the refineable equations. More...
 
class  FaceGeometry< RefineableQGeneralisedAdvectionDiffusionElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  RefineableQSUPGAdvectionDiffusionElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  AdvectionDiffusionReactionEquations
 A class for all elements that solve the Advection Diffusion Reaction equations using isoparametric elements. More...
 
class  QAdvectionDiffusionReactionElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QAdvectionDiffusionReactionElement< NREAGENT, DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QAdvectionDiffusionReactionElement< NREAGENT, 1, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  ProjectableAdvectionDiffusionReactionElement
 AdvectionDiffusionReaction upgraded to become projectable. More...
 
class  FaceGeometry< ProjectableAdvectionDiffusionReactionElement< ELEMENT > >
 Face geometry for element is the same as that for the underlying wrapped element. 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  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  RefineableQAdvectionDiffusionReactionElement
 Refineable version of QAdvectionDiffusionReactionElement. Inherit from the standard QAdvectionDiffusionReactionElement and the appropriate refineable geometric element and the refineable equations. More...
 
class  FaceGeometry< RefineableQAdvectionDiffusionReactionElement< NREAGENT, DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  TAdvectionDiffusionReactionElement
 ////////////////////////////////////////////////////////////////////// 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< TAdvectionDiffusionReactionElement< NREAGENT, 1, NNODE_1D > >
 Face geometry for the 1D TAdvectionDiffusionReactionElement elements: Point elements. 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  QAxisymAdvectionDiffusionElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QAxisymAdvectionDiffusionElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  GeneralisedAxisymAdvectionDiffusionEquations
 
class  QGeneralisedAxisymAdvectionDiffusionElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QGeneralisedAxisymAdvectionDiffusionElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  RefineableQAxisymAdvectionDiffusionElement
 Refineable version of QAxisymAdvectionDiffusionElement. Inherit from the standard QAxisymAdvectionDiffusionElement and the appropriate refineable geometric element and the refineable equations. More...
 
class  FaceGeometry< RefineableQAxisymAdvectionDiffusionElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  RefineableQGeneralisedAxisymAdvectionDiffusionElement
 Refineable version of QGeneralisedAxisymAdvectionDiffusionElement. Inherit from the standard QGeneralisedAxisymAdvectionDiffusionElement and the appropriate refineable geometric element and the refineable equations. More...
 
class  FaceGeometry< RefineableQGeneralisedAxisymAdvectionDiffusionElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  AxisymFoepplvonKarmanEquations
 A class for all isoparametric elements that solve the axisYm Foeppl von Karman equations in a displacement based formulation. More...
 
class  AxisymFoepplvonKarmanElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FSIAxisymFoepplvonKarmanElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  AxisymmetricLinearElasticityEquationsBase
 A base class for elements that solve the axisymmetric (in cylindrical polars) equations of linear elasticity. More...
 
class  AxisymmetricLinearElasticityEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  QAxisymmetricLinearElasticityElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QAxisymmetricLinearElasticityElement< NNODE_1D > >
 FaceGeometry of a linear QAxisymmetricLinearElasticityElement element. More...
 
class  ProjectableAxisymLinearElasticityElement
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableAxisymLinearElasticityElement< ELEMENT > >
 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  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  FSIAxisymmetricLinearElasticityTractionElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  TAxisymmetricLinearElasticityElement
 ////////////////////////////////////////////////////////////////////// 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  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  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  AxisymmetricNavierStokesEquations
 A class for elements that solve the unsteady axisymmetric Navier–Stokes equations in cylindrical polar coordinates, $ x_0^* = r^*$ and $ x_1^* = z^* $ with $ \partial / \partial \theta = 0 $. We're solving for the radial, axial and azimuthal (swirl) velocities, $ u_0^* = u_r^*(r^*,z^*,t^*) = u^*(r^*,z^*,t^*), \ u_1^* = u_z^*(r^*,z^*,t^*) = w^*(r^*,z^*,t^*)$ and $ u_2^* = u_\theta^*(r^*,z^*,t^*) = v^*(r^*,z^*,t^*) $, respectively, and the pressure $ p(r^*,z^*,t^*) $. This class contains the generic maths – any concrete implementation must be derived from this. More...
 
class  AxisymmetricQCrouzeixRaviartElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< AxisymmetricQCrouzeixRaviartElement >
 Face geometry of the Axisymmetric Crouzeix_Raviart elements. More...
 
class  FaceGeometry< FaceGeometry< AxisymmetricQCrouzeixRaviartElement > >
 Face geometry of face geometry of the Axisymmetric Crouzeix_Raviart elements. More...
 
class  AxisymmetricQTaylorHoodElement
 ///////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< AxisymmetricQTaylorHoodElement >
 Face geometry of the Axisymmetric Taylor_Hood elements. More...
 
class  FaceGeometry< FaceGeometry< AxisymmetricQTaylorHoodElement > >
 Face geometry of the face geometry of the Axisymmetric Taylor_Hood elements. More...
 
class  ProjectableAxisymmetricTaylorHoodElement
 Axisymmetric Taylor Hood upgraded to become projectable. More...
 
class  FaceGeometry< ProjectableAxisymmetricTaylorHoodElement< ELEMENT > >
 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  ProjectableAxisymmetricCrouzeixRaviartElement
 Crouzeix Raviart upgraded to become projectable. More...
 
class  FSIAxisymmetricQTaylorHoodElement
 Axisymmetric FSI Element. More...
 
class  FaceGeometry< FSIAxisymmetricQTaylorHoodElement >
 Face geometry of the Axisymmetric Taylor_Hood elements. More...
 
class  FaceGeometry< FaceGeometry< FSIAxisymmetricQTaylorHoodElement > >
 Face geometry of the face geometry of the Axisymmetric Taylor_Hood elements. More...
 
class  FaceGeometry< ProjectableAxisymmetricCrouzeixRaviartElement< ELEMENT > >
 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  RefineableAxisymmetricNavierStokesEquations
 Refineable version of the Axisymmetric Navier–Stokes equations. 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  FaceGeometry< RefineableAxisymmetricQTaylorHoodElement >
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< FaceGeometry< RefineableAxisymmetricQTaylorHoodElement > >
 Face geometry of the RefineableQuadQTaylorHoodElements. 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  FaceGeometry< RefineableAxisymmetricQCrouzeixRaviartElement >
 Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
 
class  FaceGeometry< FaceGeometry< RefineableAxisymmetricQCrouzeixRaviartElement > >
 Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
 
class  AxisymmetricTCrouzeixRaviartElement
 /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< AxisymmetricTCrouzeixRaviartElement >
 Face geometry of the 2D Crouzeix_Raviart elements. More...
 
class  FaceGeometry< FaceGeometry< AxisymmetricTCrouzeixRaviartElement > >
 Face geometry of the FaceGeometry of the 2D CrouzeixRaviart elements. More...
 
class  AxisymmetricTTaylorHoodElement
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< AxisymmetricTTaylorHoodElement >
 Face geometry of the Axisymmetric Taylor_Hood elements. More...
 
class  FaceGeometry< FaceGeometry< AxisymmetricTTaylorHoodElement > >
 Face geometry of the FaceGeometry of the Axisymmetric TaylorHood elements. 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  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  ProjectableAxisymmetricPoroelasticityElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableAxisymmetricPoroelasticityElement< ELEMENT > >
 Face geometry for element is the same as that for the underlying wrapped element. 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  FSILinearisedAxisymPoroelasticTractionElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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  FaceGeometry< TAxisymmetricPoroelasticityElement< 0 > >
 Face geometry for TAxisymmetricPoroelasticityElement<0> More...
 
class  FaceGeometry< TAxisymmetricPoroelasticityElement< 1 > >
 Face geometry for TAxisymmetricPoroelasticityElement<1> 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  AxisymQPVDElement
 An element that solved the AxisymmetricPVDEquations with quadratic interpolation for the positions. More...
 
class  FaceGeometry< AxisymQPVDElement >
 
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  FaceGeometry< AxisymDiagHermitePVDElement >
 Explicit definition of the face geometry for the. 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  AxisymQPVDElementWithPressure
 An Element that solves the Axisymmetric principle of virtual displacements with separately interpolated pressure, discontinuous interpolation. More...
 
class  FaceGeometry< AxisymQPVDElementWithPressure >
 
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  KirchhoffLoveBeamEquations
 A class for elements that solve the equations of Kirchhoff-Love large-displacement (but linearly-elastic) thin-beam theory. More...
 
class  HermiteBeamElement
 Hermite Kirchhoff Love beam. Implements KirchhoffLoveBeamEquations using 2-node Hermite elements as the underlying geometrical elements. 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  FaceGeometry< HermiteBeamElement >
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  ClampedSlidingHermiteBeamBoundaryConditionElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  BiharmonicEquations
 Biharmonic Equation Class - contains the equations. More...
 
class  BiharmonicElement
 biharmonic element class More...
 
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< BiharmonicElement< 1 > >
 
class  BiharmonicFluxElement
 Biharmonic Flux Element. More...
 
class  BiharmonicPreconditioner
 Biharmonic Preconditioner - for two dimensional problems. 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  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  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  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  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  StrainEnergyFunction
 Base class for strain energy functions to be used in solid mechanics computations. More...
 
class  MooneyRivlin
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  GeneralisedMooneyRivlin
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  ConstitutiveLaw
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  GeneralisedHookean
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  IsotropicStrainEnergyFunctionConstitutiveLaw
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// 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  ProjectableDarcyElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableDarcyElement< ELEMENT > >
 Face geometry for element is the same as that for the underlying wrapped element. 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  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  FaceGeometry< TRaviartThomasDarcyElement< 0 > >
 Face geometry for TRaviartThomasDarcyElement<0> More...
 
class  FaceGeometry< TRaviartThomasDarcyElement< 1 > >
 Face geometry for TRaviartThomasDarcyElement<1> 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  VolumeConstraintBoundingElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  LineVolumeConstraintBoundingElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  ElasticLineVolumeConstraintBoundingElement
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 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  AxisymmetricVolumeConstraintBoundingElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  ElasticAxisymmetricVolumeConstraintBoundingElement
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 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  SurfaceVolumeConstraintBoundingElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  ElasticSurfaceVolumeConstraintBoundingElement
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  SpineSurfaceVolumeConstraintBoundingElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// 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  PointFluidInterfaceBoundingElement
 Specialisation of the interface boundary constraint to a point. More...
 
class  LineFluidInterfaceBoundingElement
 Specialisation of the interface boundary constraint to a line. 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  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  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  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  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  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  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  SpinePointFluidInterfaceBoundingElement
 Spine version of the PointFluidInterfaceBoundingElement. More...
 
class  SpineLineFluidInterfaceBoundingElement
 Spine version of the LineFluidInterfaceBoundingElement. More...
 
class  SpineLineFluidInterfaceElement
 
class  BoundingElementType< SpineUpdateFluidInterfaceElement< FluidInterfaceElement, LineDerivatives, ELEMENT > >
 
class  SpineAxisymmetricFluidInterfaceElement
 
class  BoundingElementType< SpineUpdateFluidInterfaceElement< FluidInterfaceElement, AxisymmetricDerivatives, ELEMENT > >
 
class  SpineSurfaceFluidInterfaceElement
 
class  BoundingElementType< SpineUpdateFluidInterfaceElement< FluidInterfaceElement, SurfaceDerivatives, ELEMENT > >
 
class  ElasticUpdateFluidInterfaceElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  ElasticPointFluidInterfaceBoundingElement
 Pseudo-elasticity version of the PointFluidInterfaceBoundingElement. More...
 
class  ElasticLineFluidInterfaceBoundingElement
 Pseudo-elasticity version of the LineFluidInterfaceBoundingElement. More...
 
class  ElasticLineFluidInterfaceElement
 Specialise the elastic update template class to concrete 1D case. More...
 
class  BoundingElementType< ElasticUpdateFluidInterfaceElement< FluidInterfaceElement, LineDerivatives, ELEMENT > >
 Define the BoundingElement type associated with the 1D surface element. More...
 
class  ElasticAxisymmetricFluidInterfaceElement
 Specialise the Elastic update case to axisymmetric equations. More...
 
class  BoundingElementType< ElasticUpdateFluidInterfaceElement< FluidInterfaceElement, AxisymmetricDerivatives, ELEMENT > >
 
class  ElasticSurfaceFluidInterfaceElement
 Specialise Elastic update case to the concrete 2D case. More...
 
class  BoundingElementType< ElasticUpdateFluidInterfaceElement< FluidInterfaceElement, SurfaceDerivatives, ELEMENT > >
 
class  SurfactantTransportInterfaceElement
 Generic surfactant transport equations implemented independently of the dimension and then specialised using the generic mechanisms introduce in the FluidInterfaceElements. More...
 
class  FluidInterfaceAdditionalValues< SurfactantTransportInterfaceElement >
 ============================================================================= This is the policy class for the surfactanttransport equations which require one additional value for the surface concentration More...
 
class  SpineLineSurfactantTransportInterfaceElement
 Specialise to the Line geometry. More...
 
class  BoundingElementType< SpineUpdateFluidInterfaceElement< SurfactantTransportInterfaceElement, LineDerivatives, ELEMENT > >
 
class  SpineAxisymmetricSurfactantTransportInterfaceElement
 Specialise to the Axisymmetric geometry. More...
 
class  BoundingElementType< SpineUpdateFluidInterfaceElement< SurfactantTransportInterfaceElement, AxisymmetricDerivatives, ELEMENT > >
 
class  ElasticAxisymmetricSurfactantTransportInterfaceElement
 Specialise to the Axisymmetric geometry. More...
 
class  BoundingElementType< ElasticUpdateFluidInterfaceElement< SurfactantTransportInterfaceElement, AxisymmetricDerivatives, ELEMENT > >
 
class  SpineSurfaceSurfactantTransportInterfaceElement
 Specialise to surface geometry. More...
 
class  BoundingElementType< SpineUpdateFluidInterfaceElement< SurfactantTransportInterfaceElement, SurfaceDerivatives, ELEMENT > >
 
class  EulerEquations
 Base class for Euler equations. More...
 
class  QSpectralEulerElement
 
class  FaceGeometry< QSpectralEulerElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  DGEulerFaceElement
 FaceElement for Discontinuous Galerkin Problems. More...
 
class  DGEulerFaceReflectionElement
 FaceElement for Discontinuous Galerkin Problems with reflection boundary conditions. More...
 
class  DGSpectralEulerElement
 General DGEulerClass. Establish the template parameters. More...
 
class  DGSpectralEulerElement< 1, NNODE_1D >
 
class  FaceGeometry< DGSpectralEulerElement< 1, NNODE_1D > >
 Face geometry of the 1D DG elements. More...
 
class  DGSpectralEulerElement< 2, NNODE_1D >
 Specialisation for 2D DG Elements. More...
 
class  FaceGeometry< DGSpectralEulerElement< 2, NNODE_1D > >
 Face geometry of the DG elements. More...
 
class  FluxTransportEquations
 Base class for the flux transport equations templated by the dimension DIM. The equations that are solved are. More...
 
class  ScalarAdvectionEquations
 Base class for advection equations. More...
 
class  QSpectralScalarAdvectionElement
 
class  FaceGeometry< QSpectralScalarAdvectionElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  DGScalarAdvectionFaceElement
 FaceElement for Discontinuous Galerkin Problems. More...
 
class  DGSpectralScalarAdvectionElement
 General DGScalarAdvectionClass. Establish the template parameters. More...
 
class  DGSpectralScalarAdvectionElement< 1, NNODE_1D >
 
class  FaceGeometry< DGSpectralScalarAdvectionElement< 1, NNODE_1D > >
 Face geometry of the 1D DG elements. More...
 
class  DGSpectralScalarAdvectionElement< 2, NNODE_1D >
 Specialisation for 2D DG Elements. More...
 
class  FaceGeometry< DGSpectralScalarAdvectionElement< 2, NNODE_1D > >
 Face geometry of the DG elements. More...
 
class  QScalarAdvectionElement
 Non-spectral version of the classes. More...
 
class  FaceGeometry< QScalarAdvectionElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  DGScalarAdvectionElement
 General DGScalarAdvectionClass. Establish the template parameters. More...
 
class  DGScalarAdvectionElement< 1, NNODE_1D >
 
class  FaceGeometry< DGScalarAdvectionElement< 1, NNODE_1D > >
 Face geometry of the 1D DG elements. More...
 
class  DGScalarAdvectionElement< 2, NNODE_1D >
 Specialisation for 2D DG Elements. More...
 
class  FaceGeometry< DGScalarAdvectionElement< 2, NNODE_1D > >
 Face geometry of the DG elements. More...
 
class  DisplacementBasedFoepplvonKarmanEquations
 A class for all isoparametric elements that solve the Foeppl von Karman equations. More...
 
class  ProjectableDisplacementBasedFoepplvonKarmanElement
 Foeppl von Karman upgraded to become projectable. More...
 
class  FaceGeometry< ProjectableDisplacementBasedFoepplvonKarmanElement< ELEMENT > >
 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  FoepplvonKarmanEquations
 A class for all isoparametric elements that solve the Foeppl von Karman equations. More...
 
class  QFoepplvonKarmanElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QFoepplvonKarmanElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  ProjectableFoepplvonKarmanElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableFoepplvonKarmanElement< ELEMENT > >
 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  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  TDisplacementBasedFoepplvonKarmanElement
 ////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< TDisplacementBasedFoepplvonKarmanElement< NNODE_1D > >
 Face geometry for the TDisplacementBasedFoepplvonKarmanElement. More...
 
class  TFoepplvonKarmanElement
 ////////////////////////////////////////////////////////////////////// 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  FourierDecomposedHelmholtzBCElementBase
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  FourierDecomposedHelmholtzDtNMesh
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  FourierDecomposedHelmholtzDtNBoundaryElement
 ////////////////////////////////////////////////////////////////// More...
 
class  FourierDecomposedHelmholtzEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  QFourierDecomposedHelmholtzElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QFourierDecomposedHelmholtzElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  ProjectableFourierDecomposedHelmholtzElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableFourierDecomposedHelmholtzElement< ELEMENT > >
 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  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  TFourierDecomposedHelmholtzElement
 ////////////////////////////////////////////////////////////////////// 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  GeneralisedNewtonianAxisymmetricNavierStokesEquations
 A class for elements that solve the unsteady axisymmetric Navier–Stokes equations in cylindrical polar coordinates, $ x_0^* = r^*$ and $ x_1^* = z^* $ with $ \partial / \partial \theta = 0 $. We're solving for the radial, axial and azimuthal (swirl) velocities, $ u_0^* = u_r^*(r^*,z^*,t^*) = u^*(r^*,z^*,t^*), \ u_1^* = u_z^*(r^*,z^*,t^*) = w^*(r^*,z^*,t^*)$ and $ u_2^* = u_\theta^*(r^*,z^*,t^*) = v^*(r^*,z^*,t^*) $, respectively, and the pressure $ p(r^*,z^*,t^*) $. This class contains the generic maths – any concrete implementation must be derived from this. More...
 
class  GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement >
 Face geometry of the GeneralisedNewtonianAxisymmetric Crouzeix_Raviart elements. More...
 
class  FaceGeometry< FaceGeometry< GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement > >
 Face geometry of face geometry of the GeneralisedNewtonianAxisymmetric Crouzeix_Raviart elements. More...
 
class  GeneralisedNewtonianAxisymmetricQTaylorHoodElement
 ///////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< GeneralisedNewtonianAxisymmetricQTaylorHoodElement >
 Face geometry of the GeneralisedNewtonianAxisymmetric Taylor_Hood elements. More...
 
class  FaceGeometry< FaceGeometry< GeneralisedNewtonianAxisymmetricQTaylorHoodElement > >
 Face geometry of the face geometry of the GeneralisedNewtonianAxisymmetric Taylor_Hood elements. More...
 
class  GeneralisedNewtonianProjectableAxisymmetricTaylorHoodElement
 GeneralisedNewtonianAxisymmetric Taylor Hood upgraded to become projectable. More...
 
class  FaceGeometry< GeneralisedNewtonianProjectableAxisymmetricTaylorHoodElement< ELEMENT > >
 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  GeneralisedNewtonianProjectableAxisymmetricCrouzeixRaviartElement
 Crouzeix Raviart upgraded to become projectable. More...
 
class  FaceGeometry< GeneralisedNewtonianProjectableAxisymmetricCrouzeixRaviartElement< ELEMENT > >
 Face geometry for element is the same as that for the underlying wrapped element. 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  RefineableGeneralisedNewtonianAxisymmetricNavierStokesEquations
 Refineable version of the Axisymmetric Navier–Stokes equations. 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  FaceGeometry< RefineableGeneralisedNewtonianAxisymmetricQTaylorHoodElement >
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< FaceGeometry< RefineableGeneralisedNewtonianAxisymmetricQTaylorHoodElement > >
 Face geometry of the RefineableQuadQTaylorHoodElements. 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  FaceGeometry< RefineableGeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement >
 Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
 
class  FaceGeometry< FaceGeometry< RefineableGeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement > >
 Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
 
class  GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement
 /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement >
 Face geometry of the 2D Crouzeix_Raviart elements. More...
 
class  FaceGeometry< FaceGeometry< GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement > >
 Face geometry of the FaceGeometry of the 2D CrouzeixRaviart elements. More...
 
class  GeneralisedNewtonianAxisymmetricTTaylorHoodElement
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< GeneralisedNewtonianAxisymmetricTTaylorHoodElement >
 Face geometry of the GeneralisedNewtonianAxisymmetric Taylor_Hood elements. More...
 
class  FaceGeometry< FaceGeometry< GeneralisedNewtonianAxisymmetricTTaylorHoodElement > >
 Face geometry of the FaceGeometry of the. More...
 
class  GeneralisedNewtonianTemplateFreeNavierStokesEquationsBase
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  GeneralisedNewtonianNavierStokesEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  GeneralisedNewtonianQCrouzeixRaviartElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// 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< 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  GeneralisedNewtonianQTaylorHoodElement
 ///////////////////////////////////////////////////////////////////////// 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< 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  ProjectableGeneralisedNewtonianTaylorHoodElement
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableGeneralisedNewtonianTaylorHoodElement< ELEMENT > >
 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  ProjectableGeneralisedNewtonianCrouzeixRaviartElement
 Crouzeix Raviart upgraded to become projectable. More...
 
class  FaceGeometry< ProjectableGeneralisedNewtonianCrouzeixRaviartElement< ELEMENT > >
 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  RefineableGeneralisedNewtonianNavierStokesEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  RefineableGeneralisedNewtonianQTaylorHoodElement
 Refineable version of Taylor Hood elements. These classes can be written in total generality. More...
 
class  FaceGeometry< RefineableGeneralisedNewtonianQTaylorHoodElement< DIM > >
 Face geometry of the RefineableQTaylorHoodElements is the same as the Face geometry of the QTaylorHoodElements. 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  RefineableGeneralisedNewtonianQCrouzeixRaviartElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  PRefineableGeneralisedNewtonianQCrouzeixRaviartElement
 p-refineable version of Crouzeix Raviart elements. Generic class definitions More...
 
class  FaceGeometry< RefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM > >
 Face geometry of the RefineableQuadQCrouzeixRaviartElements. 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  GeneralisedNewtonianTCrouzeixRaviartElement
 /////////////////////////////////////////////////////////////////////////// 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< 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  GeneralisedNewtonianTTaylorHoodElement
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// 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< 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  AlgebraicNode
 //////////////////////////////////////////////////////////////////// More...
 
class  AlgebraicElementBase
 //////////////////////////////////////////////////////////////////// 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  FaceGeometry< AlgebraicElement< ELEMENT > >
 Explicit definition of the face geometry of algebraic elements: the same as the face geometry of the underlying element. More...
 
class  AlgebraicMesh
 //////////////////////////////////////////////////////////////////// More...
 
class  DummyAlgebraicMesh
 //////////////////////////////////////////////////////////////////// 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  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  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  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  AugmentedBlockFoldLinearSolver
 A custom linear solver class that is used to solve a block-factorised version of the Fold bifurcation detection 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 $\lambda$, and a solution is $R(u,\lambda) = 0 $ , where $ u $ are the unknowns in the problem. A limit point is formally specified by the augmented system of size $ 2N+1 $. 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  AugmentedBlockPitchForkLinearSolver
 A custom linear solver class that is used to solve a block-factorised version of the PitchFork bifurcation detection problem. 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 $ \lambda $ and a solution is $R(u,\lambda) = 0$, where $u$ are the unknowns in the problem. A pitchfork bifurcation may be specified by the augmented system of size $2N+2$. 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  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 $ \lambda $ and a solution is $ R(u,\lambda) = 0 $, where $ u $ are the unknowns in the problem. A Hopf bifurcation may be specified by the augmented system of size $ 3N+2 $. More...
 
class  BinaryTree
 BinaryTree class: Recursively defined, generalised binary tree. 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  BinaryTreeForest
 A BinaryTreeForest consists of a collection of BinaryTreeRoots. Each member tree can have neighbours to its left and right. 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  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  DummyBrickElement
 //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// More...
 
class  BrickMeshBase
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  DenseMatrix
 //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// 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  ComplexMatrixBase
 Abstract base class for matrices of complex doubles – adds abstract interfaces for solving, LU decomposition and multiplication by vectors. 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  CRComplexMatrix
 A class for compressed row matrices. More...
 
class  CCComplexMatrix
 A class for compressed column matrices that store doubles. 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  DGElement
 A Base class for DGElements. More...
 
class  DGMesh
 
class  SlopeLimiter
 Base class for slope limiters. More...
 
class  MinModLimiter
 
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  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  WarpedCubeDomain
 ////////////////////////////////////////////////////////////////////// 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  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  EigenSolver
 Base class for all EigenProblem solves. This simply defines standard interfaces so that different solvers can be used easily. More...
 
class  ARPACK
 Class for the ARPACK eigensolver. More...
 
class  LAPACK_QZ
 Class for the LAPACK QZ eigensolver. More...
 
class  DummyMesh
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  SolidICProblem
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  ElementWithSpecificMovingNodes
 Specific implementation of the class for specified element and node type. More...
 
class  GeneralisedElement
 A Generalised Element class. More...
 
class  FiniteElement
 A general Finite Element class. More...
 
class  PointElement
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// 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  SolidFiniteElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// 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  SolidFaceElement
 SolidFaceElements combine FaceElements and SolidFiniteElements and overload various functions so they work properly in the FaceElement context. More...
 
class  SolidPointElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  DummyFaceElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  ElementWithDragFunction
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  FreeStandingFaceElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  SolidElementWithDiagonalMassMatrix
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  NavierStokesElementWithDiagonalMassMatrices
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  ErrorEstimator
 Base class for spatial error estimators. More...
 
class  ElementWithZ2ErrorEstimator
 Base class for finite elements that can compute the quantities that are required for the Z2 error estimator. 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...
 
class  DummyErrorEstimator
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  Euler
 =========================================================== Simple first-order Euler Timestepping More...
 
class  RungeKutta
 =========================================================== Standard Runge Kutta Timestepping More...
 
class  LowStorageRungeKutta
 =========================================================== Runge Kutta Timestepping that uses low storage 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  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  QExtrudedMacroElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  QExtrudedMacroElement< 3 >
 DRAIG: FILL IN COMPLETE DESCRIPTION ONCE FINISHED... 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  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  GenericLagrangeInterpolatedProjectableElement
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  BackupMeshForProjection
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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  FSIFluidElement
 ///////////////////////////////////////////////////////////////////////// More...
 
class  FSIWallElement
 ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// 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  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  BlockTriangularPreconditioner
 //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// More...
 
class  ExactBlockPreconditioner
 //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// 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  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  MatrixBasedDiagPreconditioner
 Matrix-based diagonal preconditioner. More...
 
class  MatrixBasedLumpedPreconditioner
 Matrix-based lumped preconditioner. 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  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  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  GeneralisedNewtonianConstitutiveEquation
 A Base class defining the generalise Newtonian constitutive relation. More...
 
class  NewtonianConstitutiveEquation
 A GeneralisedNewtonianConstitutiveEquation class defining a Newtonian fluid. 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  HerschelBulkleyBerEngRegConstitutiveEquation
 A GeneralisedNewtonianConstitutiveEquation class defining a Herschel-Bulkley fluid using Bercovier and Engelman's (1980) 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  HerschelBulkleyPapRegConstitutiveEquation
 A GeneralisedNewtonianConstitutiveEquation class defining a Herschel-Bulkley fluid using Papanastasiou's (1987) regularisation. More...
 
class  HerschelBulkleyMenDutRegConstitutiveEquation
 A GeneralisedNewtonianConstitutiveEquation class defining a Herschel-Bulkley fluid using Mendes and Dutra's (2004) regularisation. 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  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  NicosConstitutiveEquation
 A GeneralisedNewtonianConstitutiveEquation class defining an arbitrary shear-thinning fluid. More...
 
class  TanhProfileConstitutiveEquation
 A GeneralisedNewtonianConstitutiveEquation class defining a fluid following a tanh-profile. 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  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  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  WarpedCircularDisk
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  WarpedCircularDiskWithAnnularInternalBoundary
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  GeomObject
 ///////////////////////////////////////////////////////////////////// More...
 
class  StraightLine
 //////////////////////////////////////////////////////////////////// More...
 
class  Ellipse
 //////////////////////////////////////////////////////////////////// More...
 
class  Circle
 //////////////////////////////////////////////////////////////////// More...
 
class  EllipticalTube
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  MGProblem
 MGProblem class; subclass of Problem. More...
 
class  MGSolver
 /////////////////////////////////////////////////////// /////////////////////////////////////////////////////// More...
 
class  MGPreconditioner
 An interface to allow scalar MG to be used as a Preconditioner. More...
 
class  GeompackQuadScaffoldMesh
 Mesh that is based on input files generated by the quadrilateral mesh generator Geompack. 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  QHermiteElement
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 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  SolidQHermiteElement
 //////////////////////////////////////////////////////////////////// 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  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  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  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< 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  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  HypreInterface
 An interface class to the suite of Hypre solvers and preconditioners to allow use of: More...
 
class  HypreSolver
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  HyprePreconditioner
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  IMRBase
 Implicit midpoint rule base class for the two implementations. 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  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  Integral
 Generic class for numerical integration schemes: 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  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_Rescaled
 Class for multidimensional Gaussian integration rules, over intervals other than -1 to 1, all intervals are rescaled in this case. 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, 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, 13 >
 
class  TGauss< 2, 9 >
 
class  TGauss< 2, 16 >
 
class  TGauss< 2, 5 >
 
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  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  GaussLegendre
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// 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  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  CG
 //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// More...
 
class  BiCGStab
 //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// More...
 
class  Smoother
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  GS
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  GS< CRDoubleMatrix >
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  DampedJacobi
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  GMRES
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  AugmentedProblemGMRES
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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  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  DistributableLinearAlgebraObject
 Base class for any linear algebra object that is distributable. Just contains storage for the LinearAlgebraDistribution object and access functions. 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  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  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  SuperLUSolver
 //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// 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  QMacroElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  QMacroElement< 2 >
 QMacroElement specialised to 2 spatial dimensions. More...
 
class  QMacroElement< 3 >
 QMacroElement specialised to 3 spatial dimensions. More...
 
class  MacroElementNodeUpdateNode
 //////////////////////////////////////////////////////////////////// More...
 
class  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  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  FaceGeometry< MacroElementNodeUpdateElement< ELEMENT > >
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  MapMatrixMixed
 MapMatrixMixed is a generalised, STL-map-based, sparse(ish) matrix class with mixed indices. More...
 
class  MapMatrix
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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  DoubleMatrixBase
 Abstract base class for matrices of doubles – adds abstract interfaces for solving, LU decomposition and multiplication by vectors. More...
 
class  SparseMatrix
 //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// 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  CRDoubleMatrix
 A class for compressed row matrices. This is a distributable object. 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  RankThreeTensor
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  RankFourTensor
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  RankFiveTensor
 /////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// More...
 
class  CCMatrix
 /////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// More...
 
class  CCDoubleMatrix
 //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// 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  SolidMesh
 General SolidMesh class. More...
 
class  Edge
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  MeshAsGeomObject
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  MumpsSolver
 Wrapper to Mumps solver. More...
 
class  NewMumpsPreconditioner
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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  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  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  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  HangInfo
 Class that contains data for hanging nodes. 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  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  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  OcTree
 OcTree class: Recursively defined, generalised octree. 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  OcTreeForest
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  OomphLibQuietException
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  OomphLibException
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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  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  Nullstream
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  OutputModifier
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  OomphInfo
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  AbsCmp
 Function-type-object to perform absolute comparison of objects. Apparently this inlines better. More...
 
class  Timer
 /////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// 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  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  MPIOutputModifier
 MPI output modifier: Precedes every output by specification of the processor ID. Output can be restricted to a single processor. 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  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  SolutionFunctor
 Function class for a simple function with no external parameters (just stores a function pointer, only needed for compatability). 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  PeriodicOrbitEquations
 
class  SpectralPeriodicOrbitElement
 QPoissonElement elements are linear/quadrilateral/brick-shaped Poisson elements with isoparametric interpolation for the function. 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  PeriodicOrbitTemporalMesh
 A special temporal mesh class. More...
 
class  PeriodicOrbitAssemblyHandlerBase
 =============================================================== Base class to avoid template complications More...
 
class  PeriodicOrbitBaseElement
 
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  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  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  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  PMLElementBase
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  PMLMeshBase
 /////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// More...
 
class  PMLQuadMeshBase
 PML mesh class. Policy class for 2D PML meshes. More...
 
class  PMLQuadMesh
 PML mesh, derived from RectangularQuadMesh. More...
 
class  PMLCornerQuadMesh
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 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  IdentityPreconditioner
 The Identity Preconditioner. More...
 
class  PreconditionerArray
 PreconditionerArray - NOTE - first implementation, a number of assumptions / simplifications were made: More...
 
class  Problem
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  NewtonSolverError
 A class to handle errors in the Newton solver. More...
 
class  ProjectableElementBase
 Template-free Base class for projectable elements. More...
 
class  ProjectableElement
 Wrapper class for projectable elements. Adds "projectability" to the underlying ELEMENT. More...
 
class  FaceGeometry< ProjectableElement< ELEMENT > >
 Face geometry for element is the same as that for the underlying wrapped element. 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
 //////////////////////////////////////////////////////////////////// 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  FaceGeometry< PseudoSolidNodeUpdateElement< BASIC, SOLID > >
 Explicit definition of the face geometry of these elements. More...
 
class  FaceGeometry< FaceGeometry< PseudoSolidNodeUpdateElement< BASIC, SOLID > > >
 Explicit definition of the face geometry of these elements. More...
 
class  RefineablePseudoSolidNodeUpdateElement
 Refineable version of the PseudoSolidNodeUpdateELement. More...
 
class  FaceGeometry< RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID > >
 Explicit definition of the face geometry of these elements. More...
 
class  FaceGeometry< FaceGeometry< RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID > > >
 Explicit definition of the face geometry of these elements. More...
 
class  QElementGeometricBase
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  QElementBase
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  QSolidElementBase
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  QElement
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  LineElementBase
 Base class for all line elements. More...
 
class  QElement< 1, NNODE_1D >
 General QElement class specialised to one spatial dimension. More...
 
class  QuadElementBase
 Base class for all quad elements. More...
 
class  QElement< 2, NNODE_1D >
 General QElement class specialised to two spatial dimensions. More...
 
class  BrickElementBase
 Base class for all brick elements. More...
 
class  QElement< 3, NNODE_1D >
 General QElement class specialised to three spatial dimensions. 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  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  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  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  OneDLegendreShapeParam
 Class that returns the shape functions associated with legendre. More...
 
class  OneDLegendreDShapeParam
 
class  SpectralElement
 
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  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  QuadMeshBase
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  QuadTree
 QuadTree class: Recursively defined, generalised quadtree. 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  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  RefineableQElement< 3 >
 Refineable version of QElement<3,NNODE_1D>. More...
 
class  RefineableSolidQElement< 3 >
 Refineable version of Solid brick 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  RefineableQSpectralElement< 3 >
 Refineable version of QuadElements that add functionality for spectral Elements. 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  PRefineableElement
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  NonRefineableElementWithHangingNodes
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  RefineableSolidElement
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  NonRefineableSolidElementWithHangingNodes
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  RefineableQElement< 1 >
 Refineable version of QElement<1,NNODE_1D>. More...
 
class  RefineableSolidQElement< 1 >
 Refineable version of Solid line elements. 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  RefineableQSpectralElement< 1 >
 Refineable version of LineElements that add functionality for spectral Elements. More...
 
class  RefineableMeshBase
 Base class for refineable meshes. Provides standardised interfaces for the following standard mesh adaptation routines: More...
 
class  TreeBasedRefineableMeshBase
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  TreeBasedRefineableMesh
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  RefineableTetMeshBase
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  RefineableQElement< 2 >
 Refineable version of QElement<2,NNODE_1D>. More...
 
class  RefineableSolidQElement< 2 >
 Refineable version of Solid quad elements. 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  RefineableQSpectralElement< 2 >
 Refineable version of QuadElements that add functionality for spectral Elements. More...
 
class  SamplePointContainerParameters
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  CGALSamplePointContainerParameters
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  BinArrayParameters
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  RefineableBinArrayParameters
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  NonRefineableBinArrayParameters
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// 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  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  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  OneDimensionalLegendreShape
 Class that returns the shape functions associated with legendre. More...
 
class  OneDimensionalLegendreDShape
 
class  OneDimensionalModalShape
 Non-templated class that returns modal hierachical shape functions based on Legendre polynomials. More...
 
class  OneDimensionalModalDShape
 
class  SimpleCubicScaffoldTetMesh
 Scaffold mesh for cubic tet mesh. 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  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  SpineFiniteElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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  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< 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  SpineMesh
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// 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  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  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  StorableShapeSolidElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  AddedMainNumberingLookup
 Class to store bi-directional lookup between added matrix row/col numbers to main matrix (SumOfMatrix) row/col numbers. 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  TFace
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  TElementShape
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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  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  TElementGeometricBase
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  TElementBase
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 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  TElementShape< 3, 2 >
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  TElementShape< 3, 3 >
 Return local coordinates of node j. More...
 
class  TBubbleEnrichedElementShape< 3, 3 >
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 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  TBubbleEnrichedElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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  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  TSolidElementBase
 Base class for Solid Telements. More...
 
class  SolidTElement
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// 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  SolidTBubbleEnrichedElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  SolidTBubbleEnrichedElement< DIM, 3 >
 Specify the SolidTBubbleEnrichedElement corresponding to the quadratic triangle. 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< TElement< 1, NNODE_1D > >
 Face geometry for the 1D TElement elements: Point elements. More...
 
class  FaceGeometry< TBubbleEnrichedElement< 2, NNODE_1D > >
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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< SolidTElement< DIM, NNODE_1D > >
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< SolidTElement< 1, NNODE_1D > >
 Face geometry for the 1D TElement elements: Point elements. More...
 
class  FaceGeometry< SolidTBubbleEnrichedElement< 2, NNODE_1D > >
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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  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  TetMeshFacet
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  TetMeshFacetedSurface
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  TetMeshFacetedClosedSurface
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  TetMeshFacetedClosedSurfaceForRemesh
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  TetMeshBase
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  TetgenScaffoldMesh
 Mesh that is based on input files generated by the tetrahedra mesh generator tetgen. 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  TimeStepper
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  Steady
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  Newmark
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  NewmarkBDF
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  BDF
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  TR
 Trapezoid rule time stepping scheme. 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  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  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  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  TriangleScaffoldMesh
 Triangle Mesh that is based on input files generated by the triangle mesh generator Triangle. More...
 
class  DoubleMultiVectorOperator
 Base class for Oomph-lib's Vector Operator classes that will be used with the DoubleMultiVector. More...
 
class  ProblemBasedShiftInvertOperator
 Class for the shift invert operation. More...
 
class  AdjointProblemBasedShiftInvertOperator
 Class for the adjoing problem shift invert operation. More...
 
class  ANASAZI
 Class for the Anasazi eigensolver. More...
 
class  DistributionPredicate
 Class to allow sorting of column indices in conversion to epetra matrix. More...
 
class  TrilinosPreconditionerBase
 Base class for Trilinos preconditioners as oomph-lib preconditioner. 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  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  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  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...
 
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  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  TriangleMeshPolyLine
 Class defining a polyline for use in Triangle Mesh generation. More...
 
class  TriangleMeshCurve
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  TriangleMeshClosedCurve
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  TriangleMeshPolygon
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  TriangleMeshOpenCurve
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// 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  HelmholtzBCElementBase
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  HelmholtzDtNMesh
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  HelmholtzAbsorbingBCElement
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  HelmholtzDtNBoundaryElement
 FaceElement used to apply Sommerfeld radiation conditon via Dirichlet to Neumann map. More...
 
class  HelmholtzEquations
 A class for all isoparametric elements that solve the Helmholtz equations. More...
 
class  QHelmholtzElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QHelmholtzElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QHelmholtzElement< 1, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  ProjectableHelmholtzElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableHelmholtzElement< ELEMENT > >
 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  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  RefineableHelmholtzEquations
 //////////////////////////////////////////////////////////////////////// More...
 
class  RefineableQHelmholtzElement
 Refineable version of 2D QHelmholtzElement elements. More...
 
class  FaceGeometry< RefineableQHelmholtzElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  THelmholtzElement
 ////////////////////////////////////////////////////////////////////// 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< THelmholtzElement< 1, NNODE_1D > >
 Face geometry for the 1D THelmholtzElement elements: Point elements. More...
 
class  ElasticityTensor
 A base class that represents the fourth-rank elasticity tensor $E_{ijkl}$ defined such that. 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  GeneralElasticityTensor
 A general elasticity tensor that provides storage for all 21 independent components. 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  LinearElasticityEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  QLinearElasticityElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  ProjectableLinearElasticityElement
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableLinearElasticityElement< ELEMENT > >
 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  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  RefineableLinearElasticityEquations
 Class for Refineable LinearElasticity equations. More...
 
class  RefineableQLinearElasticityElement
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  PRefineableQLinearElasticityElement
 p-refineable version of 2D QLinearElasticityElement elements More...
 
class  FaceGeometry< RefineableQLinearElasticityElement< 2, NNODE_1D > >
 FaceGeometry of the 2D RefineableQLinearElasticityElement elements. More...
 
class  FaceGeometry< FaceGeometry< RefineableQLinearElasticityElement< 2, NNODE_1D > > >
 FaceGeometry of the FaceGeometry of the 2D RefineableQLinearElasticityElement. More...
 
class  FaceGeometry< RefineableQLinearElasticityElement< 3, NNODE_1D > >
 FaceGeometry of the 3D RefineableQLinearElasticityElement elements. More...
 
class  FaceGeometry< FaceGeometry< RefineableQLinearElasticityElement< 3, NNODE_1D > > >
 FaceGeometry of the FaceGeometry of the 3D RefineableQLinearElasticityElement. More...
 
class  TLinearElasticityElement
 ////////////////////////////////////////////////////////////////////// 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< TLinearElasticityElement< 1, NNODE_1D > >
 Face geometry for the 1D TLinearElasticityElement elements: Point elements. More...
 
class  LinearWaveEquations
 A class for all isoparametric elements that solve the LinearWave equations. More...
 
class  QLinearWaveElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QLinearWaveElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QLinearWaveElement< 1, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  LinearWaveFluxElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  RefineableLinearWaveEquations
 Refineable version of LinearWave equations. More...
 
class  RefineableQLinearWaveElement
 Refineable version of 2D QLinearWaveElement elements. More...
 
class  FaceGeometry< RefineableQLinearWaveElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< LinearisedAxisymmetricQCrouzeixRaviartElement >
 Face geometry of the linearised axisym Crouzeix-Raviart elements. More...
 
class  FaceGeometry< FaceGeometry< LinearisedAxisymmetricQCrouzeixRaviartElement > >
 Face geometry of face geometry of the linearised axisymmetric Crouzeix Raviart elements. More...
 
class  LinearisedAxisymmetricQTaylorHoodElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< LinearisedAxisymmetricQTaylorHoodElement >
 Face geometry of the linearised axisymmetric Taylor Hood elements. More...
 
class  FaceGeometry< FaceGeometry< LinearisedAxisymmetricQTaylorHoodElement > >
 Face geometry of the face geometry of the linearised axisymmetric Taylor Hood elements. More...
 
class  RefineableLinearisedAxisymmetricNavierStokesEquations
 Refineable version of the linearised axisymmetric Navier–Stokes equations. More...
 
class  RefineableLinearisedAxisymmetricQCrouzeixRaviartElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< RefineableLinearisedAxisymmetricQCrouzeixRaviartElement >
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< FaceGeometry< RefineableLinearisedAxisymmetricQCrouzeixRaviartElement > >
 Face geometry of face geometric of the refineable linearised axisym Crouzeix-Raviart elements. More...
 
class  RefineableLinearisedAxisymmetricQTaylorHoodElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< RefineableLinearisedAxisymmetricQTaylorHoodElement >
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< FaceGeometry< RefineableLinearisedAxisymmetricQTaylorHoodElement > >
 Face geometry of face geometric of the refineable linearised axisym Taylor-Hood elements. 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
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< LinearisedQCrouzeixRaviartElement >
 Face geometry of the linearised axisym Crouzeix-Raviart elements. More...
 
class  FaceGeometry< FaceGeometry< LinearisedQCrouzeixRaviartElement > >
 Face geometry of face geometry of the linearised axisymmetric Crouzeix Raviart elements. More...
 
class  LinearisedQTaylorHoodElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< LinearisedQTaylorHoodElement >
 Face geometry of the linearised axisymmetric Taylor Hood elements. More...
 
class  FaceGeometry< FaceGeometry< LinearisedQTaylorHoodElement > >
 Face geometry of the face geometry of the linearised axisymmetric Taylor Hood elements. More...
 
class  RefineableLinearisedNavierStokesEquations
 Refineable version of the linearised axisymmetric Navier–Stokes equations. More...
 
class  RefineableLinearisedQCrouzeixRaviartElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< RefineableLinearisedQCrouzeixRaviartElement >
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< FaceGeometry< RefineableLinearisedQCrouzeixRaviartElement > >
 Face geometry of face geometric of the refineable linearised axisym Crouzeix-Raviart elements. More...
 
class  RefineableLinearisedQTaylorHoodElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< RefineableLinearisedQTaylorHoodElement >
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< FaceGeometry< RefineableLinearisedQTaylorHoodElement > >
 Face geometry of face geometric of the refineable linearised axisym Taylor-Hood elements. More...
 
class  NonLinearElasticitySmoothMesh
 /////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// More...
 
class  LinearElasticitySmoothMesh
 /////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// More...
 
class  PoissonSmoothMesh
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  AnnularDomain
 Annular domain. More...
 
class  TwoDAnnularMesh
 2D annular mesh with a unit circle in the middle and a layer of thickness h surrounding it. More...
 
class  RefineableTwoDAnnularMesh
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  BackwardStepQuadMesh
 Backward step mesh. More...
 
class  RefineableBackwardStepQuadMesh
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
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  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  SolidBrickFromTetMesh
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  RefineableBrickFromTetMesh
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  RefineableSolidBrickFromTetMesh
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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  RefineableChannelWithLeafletMesh
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  MacroElementNodeUpdateChannelWithLeafletMesh
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  MacroElementNodeUpdateRefineableChannelWithLeafletMesh
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// More...
 
class  AlgebraicChannelWithLeafletMesh
 //////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  RefineableAlgebraicChannelWithLeafletMesh
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  PseudoElasticChannelWithLeafletMesh
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// 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  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  RefineableCollapsibleChannelMesh
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  MacroElementNodeUpdateCollapsibleChannelMesh
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  MacroElementNodeUpdateRefineableCollapsibleChannelMesh
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// More...
 
class  AlgebraicCollapsibleChannelMesh
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  RefineableAlgebraicCollapsibleChannelMesh
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// 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  RefineableCylinderWithFlagMesh
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  AlgebraicCylinderWithFlagMesh
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  RefineableAlgebraicCylinderWithFlagMesh
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// 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  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  ExtrudedCubeMeshFromQuadMesh
 Mesh class that takes a 2D mesh consisting of quadrilateral elements and "extrudes" it in the z-direction. More...
 
class  RefineableExtrudedCubeMeshFromQuadMesh
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// 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  RefineableFishMesh
 //////////////////////////////////////////////////////////////////// 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  AlgebraicFishMesh
 //////////////////////////////////////////////////////////////////// More...
 
class  AlgebraicRefineableFishMesh
 //////////////////////////////////////////////////////////////////// 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  RefineableFSIDrivenCavityMesh
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  AlgebraicFSIDrivenCavityMesh
 / Alebraic node update version of FSIDrivenCavityMesh More...
 
class  RefineableAlgebraicFSIDrivenCavityMesh
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// 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  RefineableFullCircleMesh
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// 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  GmshParameters
 Class to collate parameters for Gmsh mesh generation. More...
 
class  TetEdge
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  GmshTetMesh
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  GmshTetScaffoldMesh
 
class  RefineableGmshTetMesh
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// 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  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  OneDLagrangianMesh
 1D mesh parametrised in terms of a 1D Lagrangian coordinate. The Eulerian positions of the nodes are determined by the GeomObject. More...
 
class  OneDMesh
 1D mesh consisting of N one-dimensional elements from the QElement family. More...
 
class  RefineableOneDMesh
 Refineable version of the OneDMesh. 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  RefineableQuadFromTriangleMesh
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  SolidQuadFromTriangleMesh
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  RefineableSolidQuadFromTriangleMesh
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  RefineableQuarterCircleSectorMesh
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  MacroElementNodeUpdateRefineableQuarterCircleSectorMesh
 MacroElementNodeUpdate version of RefineableQuarterCircleSectorMesh. More...
 
class  AlgebraicRefineableQuarterCircleSectorMesh
 Algebraic version of RefineableQuarterCircleSectorMesh. 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  RefineableQuarterPipeMesh
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  ElasticQuarterPipeMesh
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  ElasticRefineableQuarterPipeMesh
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// 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  RefineableQuarterTubeMesh
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  MacroElementNodeUpdateRefineableQuarterTubeMesh
 MacroElementNodeUpdate version of RefineableQuarterTubeMesh. More...
 
class  AlgebraicRefineableQuarterTubeMesh
 AlgebraicMesh version of RefineableQuarterTubeMesh. More...
 
class  RectangleWithHoleDomain
 Rectangular domain with circular whole. More...
 
class  RectangleWithHoleMesh
 Domain-based mesh for rectangular mesh with circular hole. More...
 
class  RefineableRectangleWithHoleMesh
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// 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
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  RefineableRectangleWithHoleAndAnnularRegionMesh
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  RefineableQuadMeshWithMovingCylinder
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  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  ElasticRectangularQuadMesh
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  ElasticRefineableRectangularQuadMesh
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  RefineableTetgenMesh
 
class  RefineableSolidTetgenMesh
 ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// More...
 
class  SimpleCubicMesh
 Simple cubic 3D Brick mesh class. More...
 
class  RefineableSimpleCubicMesh
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// More...
 
class  SimpleCubicTetMesh
 MySimple 3D tet mesh for TElements. 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  TetgenMesh
 Unstructured tet mesh based on output from Tetgen: http://wias-berlin.de/software/tetgen/. More...
 
class  SolidTetgenMesh
 /////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// 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  RefineableThinLayerBrickOnTetMesh
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  SolidThinLayerBrickOnTetMesh
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  RefineableSolidThinLayerBrickOnTetMesh
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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...
 
struct  classcomp
 
class  TriangleMeshParameters
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  TriangleMesh
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  RefineableTriangleMesh
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  SolidTriangleMesh
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  RefineableSolidTriangleMesh
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  RefineableTubeMesh
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// 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  XdaTetMesh
 Tet mesh made of quadratic (ten node) tets built from xda input file. More...
 
class  SolidXdaTetMesh
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  BuoyantQCrouzeixRaviartElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< BuoyantQCrouzeixRaviartElement< DIM > >
 Face geometry of the 2D Buoyant Crouzeix_Raviart elements. More...
 
class  FaceGeometry< FaceGeometry< BuoyantQCrouzeixRaviartElement< 2 > > >
 Face geometry of the Face geometry of 2D Buoyant Crouzeix_Raviart elements. More...
 
class  RefineableBuoyantQCrouzeixRaviartElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// 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  FourierDecomposedHelmholtzFluxFromNormalDisplacementBCElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  FSIPreconditioner
 //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// More...
 
class  SimpleFSIPreconditioner
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// 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  HelmholtzFluxFromNormalDisplacementBCElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  RefineableNavierStokesBoussinesqElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  RefineableAdvectionDiffusionBoussinesqElement
 //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// More...
 
class  NavierStokesBoussinesqElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< NavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT > >
 Explicit definition of the face geometry of these elements. More...
 
class  FaceGeometry< FaceGeometry< NavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT > > >
 Explicit definition of the face geometry of these elements. More...
 
class  AdvectionDiffusionBoussinesqElement
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// 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  PMLHelmholtzFluxFromNormalDisplacementBCElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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 SuperLUPreconditioner. 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
 //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// More...
 
class  PseudoElasticPreconditionerOld
 //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// More...
 
class  PseudoElasticPreconditionerSubsidiaryPreconditionerOld
 ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// More...
 
class  PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld
 ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// More...
 
class  PseudoElasticPreconditionerScalingHelperOld
 //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// More...
 
class  PicardConvergenceData
 Object that collates convergence data of Picard iteration. More...
 
class  SegregatedSolverError
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  SegregatableFSIProblem
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// 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  RefineableNavierStokesTractionElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// 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  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  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  FpPressureAdvDiffRobinBCElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  TemplateFreeNavierStokesEquationsBase
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  NavierStokesEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  QCrouzeixRaviartElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// 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< 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  QTaylorHoodElement
 ///////////////////////////////////////////////////////////////////////// More...
 
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< 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  ProjectableTaylorHoodElement
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableTaylorHoodElement< ELEMENT > >
 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  ProjectableCrouzeixRaviartElement
 Crouzeix Raviart upgraded to become projectable. More...
 
class  FaceGeometry< ProjectableCrouzeixRaviartElement< ELEMENT > >
 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  TemplateFreeNavierStokesFluxControlElementBase
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  NetFluxControlElement
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  NavierStokesFluxControlElement
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  RefineableNavierStokesFluxControlElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  FpPreconditionerAssemblyHandler
 ///////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////// More...
 
class  FpPressureAdvectionDiffusionProblem
 //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// More...
 
class  NavierStokesSchurComplementPreconditioner
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// More...
 
class  NavierStokesExactPreconditioner
 //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// 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  RefineableFpPressureAdvDiffRobinBCElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  RefineableNavierStokesEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  RefineableQTaylorHoodElement
 Refineable version of Taylor Hood elements. These classes can be written in total generality. More...
 
class  FaceGeometry< RefineableQTaylorHoodElement< DIM > >
 Face geometry of the RefineableQTaylorHoodElements is the same as the Face geometry of the QTaylorHoodElements. 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  RefineableQCrouzeixRaviartElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  PRefineableQCrouzeixRaviartElement
 p-refineable version of Crouzeix Raviart elements. Generic class definitions More...
 
class  FaceGeometry< RefineableQCrouzeixRaviartElement< DIM > >
 Face geometry of the RefineableQuadQCrouzeixRaviartElements. 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  TCrouzeixRaviartElement
 /////////////////////////////////////////////////////////////////////////// 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< 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  TTaylorHoodElement
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// 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< 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  VorticitySmootherElement
 Overloaded element that allows projection of vorticity. More...
 
class  VorticitySmoother
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  ODEElement
 Element for integrating an initial value ODE. More...
 
class  PMLMappingAndTransformedCoordinate
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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  PMLFourierDecomposedHelmholtzEquations
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  QPMLFourierDecomposedHelmholtzElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QPMLFourierDecomposedHelmholtzElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  ProjectablePMLFourierDecomposedHelmholtzElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectablePMLFourierDecomposedHelmholtzElement< ELEMENT > >
 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  PMLLayerElement< QPMLFourierDecomposedHelmholtzElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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
 ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...
 
class  TPMLFourierDecomposedHelmholtzElement
 ////////////////////////////////////////////////////////////////////// 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  PMLLayerElement< ProjectablePMLFourierDecomposedHelmholtzElement< TPMLFourierDecomposedHelmholtzElement< NNODE_1D > > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  PMLLayerElement< TPMLFourierDecomposedHelmholtzElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  ComplexDampedJacobi
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  ComplexGMRES
 The GMRES method rewritten for complex matrices. More...
 
class  HelmholtzGMRESMG
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  HelmholtzFGMRESMG
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  HelmholtzMGProblem
 HelmholtzMGProblem class; subclass of Problem. More...
 
class  HelmholtzMGPreconditioner
 /////////////////////////////////////////////////////// /////////////////////////////////////////////////////// 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  QPMLHelmholtzElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QPMLHelmholtzElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QPMLHelmholtzElement< 1, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  ProjectablePMLHelmholtzElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectablePMLHelmholtzElement< ELEMENT > >
 Face geometry for element is the same as that for the underlying wrapped element. More...
 
class  PMLLayerElement< QPMLHelmholtzElement< 2, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  PMLHelmholtzFluxElement
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  RefineablePMLHelmholtzEquations
 //////////////////////////////////////////////////////////////////////// More...
 
class  RefineableQPMLHelmholtzElement
 Refineable version of QPMLHelmholtzElement elements. More...
 
class  FaceGeometry< RefineableQPMLHelmholtzElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  PMLLayerElement< RefineableQPMLHelmholtzElement< 2, NNODE_1D > >
 Policy class defining the elements to be used in the actual PML layers. Same! More...
 
class  TPMLHelmholtzElement
 ////////////////////////////////////////////////////////////////////// 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< TPMLHelmholtzElement< 1, NNODE_1D > >
 Face geometry for the 1D TPMLHelmholtzElement elements: Point elements. More...
 
class  PMLLayerElement< TPMLHelmholtzElement< 2, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  PMLLayerElement< ProjectablePMLHelmholtzElement< TPMLHelmholtzElement< 2, NNODE_1D > > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  PMLTimeHarmonicElasticityTensor
 A base class that represents the fourth-rank elasticity tensor $E_{ijkl}$ 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  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  PMLTimeHarmonicLinearElasticityEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  QPMLTimeHarmonicLinearElasticityElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  ProjectablePMLTimeHarmonicLinearElasticityElement
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectablePMLTimeHarmonicLinearElasticityElement< ELEMENT > >
 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  PMLLayerElement< QPMLTimeHarmonicLinearElasticityElement< 2, NNODE_1D > >
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 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  TPMLTimeHarmonicLinearElasticityElement
 ////////////////////////////////////////////////////////////////////// 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< TPMLTimeHarmonicLinearElasticityElement< 1, NNODE_1D > >
 Face geometry for the 1D TPMLTimeHarmonicLinearElasticityElement elements: Point elements. More...
 
class  PMLLayerElement< TPMLTimeHarmonicLinearElasticityElement< 2, NNODE_1D > >
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 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  PMLLayerElement< ProjectablePMLTimeHarmonicLinearElasticityElement< TPMLTimeHarmonicLinearElasticityElement< 2, NNODE_1D > > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  PoissonEquations
 A class for all isoparametric elements that solve the Poisson equations. More...
 
class  QPoissonElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QPoissonElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QPoissonElement< 1, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  ProjectablePoissonElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectablePoissonElement< ELEMENT > >
 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  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  RefineablePoissonEquations
 //////////////////////////////////////////////////////////////////////// More...
 
class  RefineableQPoissonElement
 Refineable version of 2D QPoissonElement elements. More...
 
class  PRefineableQPoissonElement
 p-refineable version of 2D QPoissonElement elements More...
 
class  FaceGeometry< RefineableQPoissonElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  RefineableQSpectralPoissonElement
 Refineable version of 2D QSpectralPoissonElement elements. 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  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  FaceGeometry< QSpectralPoissonElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QSpectralPoissonElement< 1, NNODE_1D > >
 Face geometry for the 1D QPoissonElement elements: Point elements. More...
 
class  TPoissonElement
 ////////////////////////////////////////////////////////////////////// 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< TPoissonElement< 1, NNODE_1D > >
 Face geometry for the 1D TPoissonElement elements: Point elements. 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  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  PolarCrouzeixRaviartElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< PolarCrouzeixRaviartElement >
 Face geometry of the 2D Crouzeix_Raviart elements. More...
 
class  PolarTaylorHoodElement
 ///////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< PolarTaylorHoodElement >
 Face geometry of the 2D Taylor_Hood elements. 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  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  FaceGeometry< RefineablePolarTaylorHoodElement >
 Face geometry of the RefineablePolarTaylorHoodElements is the same as the Face geometry of the PolarTaylorHoodElements. More...
 
class  RefineablePolarCrouzeixRaviartElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< RefineablePolarCrouzeixRaviartElement >
 Face geometry of the RefineableQuadQCrouzeixRaviartElements. 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  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  TPoroelasticityElement
 Element which solves the Darcy equations using TElements. More...
 
class  FaceGeometry< TPoroelasticityElement< 0 > >
 Face geometry for TPoroelasticityElement<0> More...
 
class  FaceGeometry< TPoroelasticityElement< 1 > >
 Face geometry for TPoroelasticityElement<1> 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, $\mbox{\boldmath$X$}$, and a single angle, $\phi$, 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  KirchhoffLoveShellEquations
 A class for elements that solves the equations of Kirchhoff Love shell thin-shell theory. 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  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  FaceGeometry< HermiteShellElement >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FSIDiagHermiteShellElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  ClampedHermiteShellBoundaryConditionElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  RefineablePVDEquations
 Class for Refineable PVD equations. More...
 
class  RefineableQPVDElement
 Class for refineable QPVDElement elements. More...
 
class  FaceGeometry< RefineableQPVDElement< 2, NNODE_1D > >
 FaceGeometry of the 2D RefineableQPVDElement elements. More...
 
class  FaceGeometry< FaceGeometry< RefineableQPVDElement< 2, NNODE_1D > > >
 FaceGeometry of the FaceGeometry of the 2D RefineableQPVDElement. More...
 
class  FaceGeometry< RefineableQPVDElement< 3, NNODE_1D > >
 FaceGeometry of the 3D RefineableQPVDElement elements. More...
 
class  FaceGeometry< FaceGeometry< RefineableQPVDElement< 3, NNODE_1D > > >
 FaceGeometry of the FaceGeometry of the 3D RefineableQPVDElement. 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  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  FaceGeometry< RefineableQPVDElementWithPressure< 2 > >
 FaceGeometry of the 2D RefineableQPVDElementWithPressure. More...
 
class  FaceGeometry< FaceGeometry< RefineableQPVDElementWithPressure< 2 > > >
 FaceGeometry of the FaceGeometry of the 2D RefineableQPVDElementWithPressure. More...
 
class  FaceGeometry< RefineableQPVDElementWithPressure< 3 > >
 FaceGeometry of the 3D RefineableQPVDElementWithPressure. More...
 
class  FaceGeometry< FaceGeometry< RefineableQPVDElementWithPressure< 3 > > >
 FaceGeometry of the FaceGeometry of the 3D RefineableQPVDElementWithPressure. 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  FaceGeometry< RefineableQPVDElementWithContinuousPressure< 2 > >
 FaceGeometry of the 2D RefineableQPVDElementWithContinuousPressure elements. More...
 
class  FaceGeometry< FaceGeometry< RefineableQPVDElementWithContinuousPressure< 2 > > >
 FaceGeometry of the FaceGeometry of the 2D RefineableQPVDElementWithContinuousPressure. More...
 
class  FaceGeometry< RefineableQPVDElementWithContinuousPressure< 3 > >
 FaceGeometry of the 3D RefineableQPVDElementWithContinuousPressure. More...
 
class  FaceGeometry< FaceGeometry< RefineableQPVDElementWithContinuousPressure< 3 > > >
 FaceGeometry of the FaceGeometry of the 3D RefineableQPVDElementWithContinuousPressue. 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  PVDEquations
 A class for elements that solve the equations of solid mechanics, based on the principle of virtual displacements in cartesian coordinates. 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  FaceGeometry< QPVDElement< 2, NNODE_1D > >
 FaceGeometry of a 2D QPVDElement element. More...
 
class  FaceGeometry< FaceGeometry< QPVDElement< 2, NNODE_1D > > >
 FaceGeometry of the FaceGeometry of the 2D QPVDElement. More...
 
class  FaceGeometry< QPVDElement< 3, NNODE_1D > >
 FaceGeometry of a 3D QPVDElement element. More...
 
class  FaceGeometry< FaceGeometry< QPVDElement< 3, NNODE_1D > > >
 FaceGeometry of FaceGeometry of a 3D QPVDElement element. More...
 
class  HermitePVDElement
 An Element that solves the principle of virtual diplacements using Hermite interpolation for the variable positions. More...
 
class  ProjectablePVDElement
 PVDElementWithContinuousPressure upgraded to become projectable. More...
 
class  FaceGeometry< ProjectablePVDElement< ELEMENT > >
 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  PVDEquationsWithPressure
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  QPVDElementWithPressure
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QPVDElementWithPressure< 2 > >
 FaceGeometry of 2D QPVDElementWithPressure. More...
 
class  FaceGeometry< FaceGeometry< QPVDElementWithPressure< 2 > > >
 FaceGeometry of FaceGeometry of 2D QPVDElementWithPressure. More...
 
class  FaceGeometry< QPVDElementWithPressure< 3 > >
 FaceGeometry of 3D QPVDElementWithPressure. More...
 
class  FaceGeometry< FaceGeometry< QPVDElementWithPressure< 3 > > >
 FaceGeometry of FaceGeometry of 3D QPVDElementWithPressure. More...
 
class  QPVDElementWithContinuousPressure
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QPVDElementWithContinuousPressure< 2 > >
 FaceGeometry for 2D QPVDElementWithContinuousPressure element. More...
 
class  FaceGeometry< FaceGeometry< QPVDElementWithContinuousPressure< 2 > > >
 FaceGeometry of FaceGeometry for 2D QPVDElementWithContinuousPressure element. More...
 
class  FaceGeometry< QPVDElementWithContinuousPressure< 3 > >
 FaceGeometry for 3D QPVDElementWithContinuousPressure element. More...
 
class  FaceGeometry< FaceGeometry< QPVDElementWithContinuousPressure< 3 > > >
 FaceGeometry of FaceGeometry for 3D QPVDElementWithContinuousPressure element. More...
 
class  TPVDElement
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< TPVDElement< 2, NNODE_1D > >
 FaceGeometry of a 2D TPVDElement element. More...
 
class  FaceGeometry< FaceGeometry< TPVDElement< 2, NNODE_1D > > >
 FaceGeometry of the FaceGeometry of the 2D TPVDElement. More...
 
class  FaceGeometry< TPVDElement< 3, NNODE_1D > >
 FaceGeometry of a 3D TPVDElement element. More...
 
class  FaceGeometry< FaceGeometry< TPVDElement< 3, NNODE_1D > > >
 FaceGeometry of FaceGeometry of a 3D TPVDElement element. More...
 
class  TPVDBubbleEnrichedElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< TPVDBubbleEnrichedElement< 2, NNODE_1D > >
 FaceGeometry of a 2D TPVDBubbleEnrichedElement element. More...
 
class  FaceGeometry< FaceGeometry< TPVDBubbleEnrichedElement< 2, NNODE_1D > > >
 FaceGeometry of the FaceGeometry of the 2D TPVDBubbleEnrichedElement. More...
 
class  FaceGeometry< TPVDBubbleEnrichedElement< 3, NNODE_1D > >
 FaceGeometry of a 3D TPVDBubbleEnrichedElement element. More...
 
class  FaceGeometry< FaceGeometry< TPVDBubbleEnrichedElement< 3, NNODE_1D > > >
 FaceGeometry of FaceGeometry of a 3D TPVDElement element. 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  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  ProjectablePVDElementWithContinuousPressure
 PVDElementWithContinuousPressure upgraded to become projectable. More...
 
class  FaceGeometry< ProjectablePVDElementWithContinuousPressure< ELEMENT > >
 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  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  PressureBasedSolidExactPreconditioner
 //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// 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  RefineableSolidTractionElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  FSISolidTractionElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  RefineableFSISolidTractionElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  ImposeDisplacementByLagrangeMultiplierElement
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// More...
 
class  RefineableImposeDisplacementByLagrangeMultiplierElement
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// More...
 
class  FSIImposeDisplacementByLagrangeMultiplierElement
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// More...
 
class  RefineableFSIImposeDisplacementByLagrangeMultiplierElement
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// 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  ExactDGPBlockPreconditioner
 General purpose block tridiagonal preconditioner. By default SuperLUPreconditioner (or SuperLUDistPreconditioner) 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  BandedBlockTriangularPreconditioner
 General purpose block triangular preconditioner. By default this operates as an upper triangular preconditioner. Also, by default SuperLUPreconditioner (or SuperLUDistPreconditioner) 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  SpaceTimeNavierStokesSubsidiaryPreconditioner
 General purpose block triangular preconditioner. By default this is Upper triangular. Also, by default SuperLUPreconditioner (or SuperLUDistPreconditioner) 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  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  NavierStokesSpaceTimeTractionElement
 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  RefineableNavierStokesSpaceTimeTractionElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  FpPressureAdvDiffRobinBCSpaceTimeElementBase
 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  FpPressureAdvDiffRobinBCSpaceTimeElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  TemplateFreeSpaceTimeNavierStokesEquationsBase
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  SpaceTimeNavierStokesEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  QTaylorHoodSpaceTimeElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QTaylorHoodSpaceTimeElement< 2 > >
 Face geometry of the 2D Taylor_Hood elements. More...
 
class  FaceGeometry< FaceGeometry< QTaylorHoodSpaceTimeElement< 2 > > >
 Face geometry of the FaceGeometry of the 2D Taylor Hoodelements. More...
 
class  ProjectableTaylorHoodSpaceTimeElement
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableTaylorHoodSpaceTimeElement< ELEMENT > >
 Face geometry for element is the same as that for the underlying wrapped element. More...
 
class  FaceGeometry< FaceGeometry< ProjectableTaylorHoodSpaceTimeElement< ELEMENT > > >
 Face geometry of the Face Geometry for element is the same as that for the underlying wrapped element. More...
 
class  RefineableFpPressureAdvDiffRobinBCSpaceTimeElement
 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  RefineableSpaceTimeNavierStokesEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  RefineableQTaylorHoodSpaceTimeElement
 Refineable version of Taylor Hood elements. These classes can be written in total generality. More...
 
class  FaceGeometry< RefineableQTaylorHoodSpaceTimeElement< DIM > >
 Face geometry of the RefineableQTaylorHoodSpaceTimeElements is the same as the Face geometry of the QTaylorHoodSpaceTimeElements. More...
 
class  FaceGeometry< FaceGeometry< RefineableQTaylorHoodSpaceTimeElement< DIM > > >
 Face geometry of the face geometry of the RefineableQTaylorHoodSpaceTimeElements is the same as the Face geometry of the Face geometry of QTaylorHoodSpaceTimeElements. More...
 
class  BlockPrecQTaylorHoodSpaceTimeElement
 Block preconditionable version of the QTaylorHoodSpaceTimeElement element. More...
 
class  BlockPrecQTaylorHoodMixedOrderSpaceTimeElement
 Block preconditionable version of the QTaylorHoodMixedOrderSpaceTimeElement. 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  RefineableNavierStokesMixedOrderSpaceTimeTractionElement
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// 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  FpPressureAdvDiffRobinBCMixedOrderSpaceTimeElement
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  TemplateFreeSpaceTimeNavierStokesMixedOrderEquationsBase
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  SpaceTimeNavierStokesMixedOrderEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  QTaylorHoodMixedOrderSpaceTimeElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QTaylorHoodMixedOrderSpaceTimeElement< 2 > >
 Face geometry of the 2D Taylor_Hood elements. More...
 
class  FaceGeometry< FaceGeometry< QTaylorHoodMixedOrderSpaceTimeElement< 2 > > >
 Face geometry of the FaceGeometry of the 2D Taylor Hoodelements. More...
 
class  ProjectableTaylorHoodMixedOrderSpaceTimeElement
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableTaylorHoodMixedOrderSpaceTimeElement< ELEMENT > >
 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  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  RefineableSpaceTimeNavierStokesMixedOrderEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  RefineableQTaylorHoodMixedOrderSpaceTimeElement
 Refineable version of Taylor Hood elements. These classes can be written in total generality. More...
 
class  FaceGeometry< RefineableQTaylorHoodMixedOrderSpaceTimeElement< DIM > >
 Face geometry of the class: RefineableQTaylorHoodMixedOrderSpaceTimeElements is the same as the Face geometry of: QTaylorHoodMixedOrderSpaceTimeElements. 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  RefineableSpaceTimeUnsteadyHeatEquations
 Refineable version of Unsteady Heat equations. More...
 
class  RefineableQUnsteadyHeatSpaceTimeElement
 Refineable version of 2D QUnsteadyHeatSpaceTimeElement elements. More...
 
class  FaceGeometry< RefineableQUnsteadyHeatSpaceTimeElement< SPATIAL_DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  BlockPrecQUnsteadyHeatSpaceTimeElement
 Block preconditionable version of UnsteadyHeatSpaceTimeElement. More...
 
class  BlockPrecRefineableQUnsteadyHeatSpaceTimeElement
 Block preconditionable version of UnsteadyHeatSpaceTimeElement. More...
 
class  SpaceTimeUnsteadyHeatEquationsBase
 Base class so that we don't need to know the dimension just to set the source function! More...
 
class  SpaceTimeUnsteadyHeatEquations
 A class for all isoparametric elements that solve the SpaceTimeUnsteadyHeat equations. More...
 
class  QUnsteadyHeatSpaceTimeElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QUnsteadyHeatSpaceTimeElement< SPATIAL_DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QUnsteadyHeatSpaceTimeElement< 1, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  ProjectableUnsteadyHeatSpaceTimeElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableUnsteadyHeatSpaceTimeElement< ELEMENT > >
 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  SpaceTimeUnsteadyHeatMixedOrderEquations
 A class for all isoparametric elements that solve the SpaceTimeUnsteadyHeatMixedOrder equations. More...
 
class  QUnsteadyHeatMixedOrderSpaceTimeElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QUnsteadyHeatMixedOrderSpaceTimeElement< SPATIAL_DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QUnsteadyHeatMixedOrderSpaceTimeElement< 1, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  ProjectableUnsteadyHeatMixedOrderSpaceTimeElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableUnsteadyHeatMixedOrderSpaceTimeElement< ELEMENT > >
 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  RefineableSpaceTimeUnsteadyHeatMixedOrderEquations
 Refineable version of Unsteady Heat equations. More...
 
class  RefineableQUnsteadyHeatMixedOrderSpaceTimeElement
 Refineable version of 2D QUnsteadyHeatMixedOrderSpaceTimeElement elements. More...
 
class  FaceGeometry< RefineableQUnsteadyHeatMixedOrderSpaceTimeElement< SPATIAL_DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  BlockPrecQUnsteadyHeatMixedOrderSpaceTimeElement
 Block preconditionable version of UnsteadyHeatMixedOrderSpaceTimeElement. More...
 
class  BlockPrecRefineableQUnsteadyHeatMixedOrderSpaceTimeElement
 Block preconditionable version of UnsteadyHeatSpaceTimeElement. 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  RefineableQSphericalAdvectionDiffusionElement
 Refineable version of QSphericalAdvectionDiffusionElement. Inherit from the standard QSphericalAdvectionDiffusionElement and the appropriate refineable geometric element and the refineable equations. More...
 
class  FaceGeometry< RefineableQSphericalAdvectionDiffusionElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  QSphericalAdvectionDiffusionElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QSphericalAdvectionDiffusionElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  SphericalAdvectionDiffusionFluxElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  RefineableSphericalNavierStokesEquations
 Refineable version of the Spherical Navier–Stokes equations. 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  FaceGeometry< RefineableQSphericalTaylorHoodElement >
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< FaceGeometry< RefineableQSphericalTaylorHoodElement > >
 Face geometry of the RefineableQuadQTaylorHoodElements. 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  FaceGeometry< RefineableQSphericalCrouzeixRaviartElement >
 Face geometry of the RefineableQuadQCrouzeixRaviartElements. More...
 
class  FaceGeometry< FaceGeometry< RefineableQSphericalCrouzeixRaviartElement > >
 Face geometry of the RefineableQuadQCrouzeixRaviartElements. 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  QSphericalCrouzeixRaviartElement
 /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QSphericalCrouzeixRaviartElement >
 Face geometry of the Spherical Crouzeix_Raviart elements. More...
 
class  FaceGeometry< FaceGeometry< QSphericalCrouzeixRaviartElement > >
 Face geometry of the FaceGeometry of the Spherical Crouzeix_Raviart elements. More...
 
class  QSphericalTaylorHoodElement
 ///////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QSphericalTaylorHoodElement >
 Face geometry of the Spherical Taylor_Hood elements. More...
 
class  FaceGeometry< FaceGeometry< QSphericalTaylorHoodElement > >
 Face geometry of the FaceGeometry of the 2D Taylor Hoodelements. More...
 
class  SteadyAxisymAdvectionDiffusionEquations
 A class for all elements that solve the Steady Axisymmetric Advection Diffusion equations using isoparametric elements. More...
 
class  QSteadyAxisymAdvectionDiffusionElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QSteadyAxisymAdvectionDiffusionElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  SteadyAxisymAdvectionDiffusionFluxElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  TimeHarmonicFourierDecomposedLinearElasticityEquationsBase
 A base class for elements that solve the Fourier decomposed (in cylindrical polars) equations of time-harmonic linear elasticity. More...
 
class  TimeHarmonicFourierDecomposedLinearElasticityEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  QTimeHarmonicFourierDecomposedLinearElasticityElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QTimeHarmonicFourierDecomposedLinearElasticityElement< NNODE_1D > >
 FaceGeometry of a linear QTimeHarmonicFourierDecomposedLinearElasticityElement element. More...
 
class  TTimeHarmonicFourierDecomposedLinearElasticityElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< TTimeHarmonicFourierDecomposedLinearElasticityElement< NNODE_1D > >
 FaceGeometry of a linear TTimeHarmonicFourierDecomposedLinearElasticityElement element. More...
 
class  ProjectableTimeHarmonicFourierDecomposedLinearElasticityElement
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableTimeHarmonicFourierDecomposedLinearElasticityElement< ELEMENT > >
 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  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  RefineableTimeHarmonicLinearElasticityEquations
 Class for Refineable TimeHarmonicLinearElasticity equations. More...
 
class  RefineableQTimeHarmonicLinearElasticityElement
 /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< RefineableQTimeHarmonicLinearElasticityElement< 2, NNODE_1D > >
 FaceGeometry of the 2D RefineableQTimeHarmonicLinearElasticityElement elements. More...
 
class  FaceGeometry< FaceGeometry< RefineableQTimeHarmonicLinearElasticityElement< 2, NNODE_1D > > >
 FaceGeometry of the FaceGeometry of the 2D RefineableQTimeHarmonicLinearElasticityElement. More...
 
class  FaceGeometry< RefineableQTimeHarmonicLinearElasticityElement< 3, NNODE_1D > >
 FaceGeometry of the 3D RefineableQTimeHarmonicLinearElasticityElement elements. More...
 
class  FaceGeometry< FaceGeometry< RefineableQTimeHarmonicLinearElasticityElement< 3, NNODE_1D > > >
 FaceGeometry of the FaceGeometry of the 3D RefineableQTimeHarmonicLinearElasticityElement. More...
 
class  TimeHarmonicElasticityTensor
 A base class that represents the fourth-rank elasticity tensor $E_{ijkl}$ defined such that. 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  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  TimeHarmonicLinearElasticityEquations
 //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
 
class  QTimeHarmonicLinearElasticityElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  ProjectableTimeHarmonicLinearElasticityElement
 ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableTimeHarmonicLinearElasticityElement< ELEMENT > >
 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  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  TTimeHarmonicLinearElasticityElement
 ////////////////////////////////////////////////////////////////////// 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< TTimeHarmonicLinearElasticityElement< 1, NNODE_1D > >
 Face geometry for the 1D TTimeHarmonicLinearElasticityElement elements: Point elements. More...
 
class  RefineableUnsteadyHeatEquations
 //////////////////////////////////////////////////////////////////////// More...
 
class  RefineableQUnsteadyHeatElement
 Refineable version of 2D QUnsteadyHeatElement elements. More...
 
class  FaceGeometry< RefineableQUnsteadyHeatElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  TUnsteadyHeatElement
 ////////////////////////////////////////////////////////////////////// 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< TUnsteadyHeatElement< 1, NNODE_1D > >
 Face geometry for the 1D TUnsteadyHeatElement elements: Point elements. More...
 
class  UnsteadyHeatEquationsBase
 Base class so that we don't need to know the dimension just to set the source function! More...
 
class  UnsteadyHeatEquations
 A class for all isoparametric elements that solve the UnsteadyHeat equations. More...
 
class  QUnsteadyHeatElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QUnsteadyHeatElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QUnsteadyHeatElement< 1, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  ProjectableUnsteadyHeatElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< ProjectableUnsteadyHeatElement< ELEMENT > >
 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  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  TWomersleyElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< TWomersleyElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< TWomersleyElement< 1, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  TemplateFreeWomersleyImpedanceTubeBase
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  NavierStokesImpedanceTractionElementBase
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  WomersleyEquations
 ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  ImposeFluxForWomersleyElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  QWomersleyElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  WomersleyProblem
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  WomersleyImpedanceTubeBase
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QWomersleyElement< DIM, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QWomersleyElement< 1, NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  TemplateFreeWomersleyMeshBase
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  WomersleyMesh
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  WomersleyOutflowImpedanceTube
 ///////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  NavierStokesImpedanceTractionElement
 ///////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...
 
class  NavierStokesWomersleyPressureControlElement
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  NetFluxControlElementForWomersleyPressureControl
 /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// More...
 
class  RefineableYoungLaplaceEquations
 //////////////////////////////////////////////////////////////////////// More...
 
class  RefineableQYoungLaplaceElement
 Refineable version of 2D QYoungLaplaceElement elements. More...
 
class  FaceGeometry< RefineableQYoungLaplaceElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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  QYoungLaplaceElement
 //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// More...
 
class  FaceGeometry< QYoungLaplaceElement< NNODE_1D > >
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
class  HeightControlElement
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// 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. More...
 
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. More...
 

Enumerations

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 *)
 ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
 
std::ostream & operator<< (std::ostream &out, const DoubleVector &v)
 output operator More...
 
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. More...
 
std::ostream & operator<< (std::ostream &stream, LinearAlgebraDistribution &dist)
 output operator More...
 
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. More...
 
double get_total_memory_usage_in_bytes ()
 Function to calculate the number of bytes used in calculating and storing the LU factors. More...
 
double get_lu_factor_memory_usage_in_bytes_dist ()
 Function to calculate the number of bytes used to store the LU factors. More...
 
double get_total_memory_usage_in_bytes_dist ()
 Function to calculate the number of bytes used in calculating and storing the LU factors. More...
 
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. More...
 
void pause (std::string message)
 Pause and display message. More...
 
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: More...
 
template<class Target , class Source >
Target checked_static_cast (Source *x)
 Checked static cast. Only use this cast if ALL of these are true: More...
 
void METIS_PartGraphKway (int *, int *, int *, int *, int *, int *, int *, int *, int *, int *, int *)
 Metis graph partitioning function. More...
 
void METIS_PartGraphVKway (int *, int *, int *, int *, int *, int *, int *, int *, int *, int *, int *)
 Metis graph partitioning function – decomposes nodal graph based on minimum communication volume. More...
 
void triangulate (char *triswitches, struct oomph::TriangulateIO *in, struct oomph::TriangulateIO *out, struct oomph::TriangulateIO *vorout)
 

Variables

Nullstream oomph_nullstream
 ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// More...
 
OomphInfo oomph_info
 Single (global) instantiation of the OomphInfo object – this is used throughout the library as a "replacement" for std::cout. More...
 
OutputModifier default_output_modifier
 Single global instatiation of the default output modifier. More...
 
MPIOutputModifier oomph_mpi_output
 Single (global) instantiation of the mpi output modifier. More...
 
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 1290 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 1282 of file elements.h.

Enumeration Type Documentation

◆ 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.

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 313 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 335 of file oomph_utilities.h.

◆ 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().

◆ METIS_PartGraphKway()

void oomph::METIS_PartGraphKway ( int *  ,
int *  ,
int *  ,
int *  ,
int *  ,
int *  ,
int *  ,
int *  ,
int *  ,
int *  ,
int *   
)

Metis graph partitioning function.

Referenced by oomph::METIS::partition_distributed_mesh(), and oomph::METIS::partition_mesh().

◆ METIS_PartGraphVKway()

void oomph::METIS_PartGraphVKway ( int *  ,
int *  ,
int *  ,
int *  ,
int *  ,
int *  ,
int *  ,
int *  ,
int *  ,
int *  ,
int *   
)

Metis graph partitioning function – decomposes nodal graph based on minimum communication volume.

Referenced by oomph::METIS::partition_distributed_mesh(), and oomph::METIS::partition_mesh().

◆ 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)

◆ 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::Data::eqn_number(), oomph::Data::is_a_copy(), oomph::Data::nvalue(), oomph::Data::set_value(), and oomph::Data::value().

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

◆ superlu()

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

◆ 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 
)

◆ 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 
)

◆ 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 
)

◆ triangulate()

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

Variable Documentation

◆ Bottom_left_sorter

struct oomph::classcomp oomph::Bottom_left_sorter

◆ default_output_modifier

OutputModifier oomph::default_output_modifier

Single global instatiation of the default output modifier.

Definition at line 325 of file oomph_definitions.cc.

◆ 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 319 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_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(), CGALSamplePointContainer::CGALSamplePointContainer(), 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::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_continuation(), oomph::Mesh::node_update(), NonRefineableBinArray::NonRefineableBinArray(), oomph::DGEulerFaceElement< ELEMENT >::numerical_flux(), 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(), RefineableBin::output(), oomph::Mesh::output(), oomph::ClampedHermiteShellBoundaryConditionElement::output(), RefineableBin::output_bin_vertices(), oomph::Mesh::output_fct(), RefineableBinArray::output_neighbouring_bins(), oomph::TreeBasedRefineableMeshBase::p_adapt(), oomph::Problem::p_adapt(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::Problem::p_refine_selected_elements(), oomph::Problem::p_refine_uniformly(), oomph::Problem::p_refine_uniformly_aux(), 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(), BinArray::profile_get_neighbouring_bins_helper(), 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_uniformly(), oomph::Problem::refine_uniformly_aux(), RefineableBinArray::RefineableBinArray(), 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::NewMumpsPreconditioner::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::MumpsSolver::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::HelmholtzGMRESMG< MATRIX >::solve(), oomph::HelmholtzFGMRESMG< MATRIX >::solve(), oomph::HypreSolver::solve(), oomph::TrilinosAztecOOSolver::solve(), oomph::ARPACK::solve_eigenproblem(), oomph::ANASAZI::solve_eigenproblem(), oomph::ANASAZI::solve_eigenproblem_legacy(), oomph::ARPACK::solve_eigenproblem_legacy(), 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::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::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(), and oomph::HyprePreconditioner::~HyprePreconditioner().

◆ oomph_mpi_output

MPIOutputModifier oomph::oomph_mpi_output

Single (global) instantiation of the mpi output modifier.

Definition at line 947 of file oomph_utilities.cc.

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

◆ oomph_nullstream

Nullstream oomph::oomph_nullstream