oomph Namespace Reference

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

Namespaces
	MeshExtrusionHelpers

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

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

Variables
struct oomph::classcomp	Bottom_left_sorter

Detailed Description

////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////

Function Documentation

triangulate()

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

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

Variable Documentation

Bottom_left_sorter

struct oomph::classcomp oomph::Bottom_left_sorter

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