A 2D cell: quadrilateral. More...

#include <cell2D.hh>

Inheritance diagram for concepts::Quad2d:

Collaboration diagram for concepts::Quad2d:

Classes
struct	Index
	Subclass of Quad2d representing its index. More...
Public Member Functions
Real3d	center () const
	Returns the center of the cell.
Real2d	chi (Real xi, Real eta) const
	Evaluates the element map.
virtual Quad2d *	child (uint i)
	Returns a child.
virtual const Quad2d *	child (uint i) const
	Returns a child.
const Quad2d *	child (uint i, Real xi, Real eta, Real &xiC, Real &etaC) const
	Returns a child.
Quad2d *	clone (Quad &cntr, MappingQuad2d *map) const
	Returns a copy of itself.
Quad &	connector () const
	Returns the quadrilateral connector (topology)
const MappingEdge2d *	edgeMap (uint edge) const
	Returns the mapping of an edge.
Real3d	elemMap (const Real2d &coord_local) const
	Element map from point local coordinates in 2D.
virtual Real3d	elemMap (const Real3d &coord_local) const
	Element map from point local coordinates in 3D.
virtual Real3d	elemMap (const Real coord_local) const
	Element map from point local coordinates in 1D.
const Quad2dSubdivision *	getStrategy () const
	Returns the subdivision strategy of this quad.
bool	hasChildren () const
	Returns true if there is a least one child.
MapReal2d	jacobian (const Real xi, const Real eta) const
	Computes the Jacobian for `xi`, `eta` $\in [0,1]$ .
Real	jacobianDeterminant (const Real xi, const Real eta) const
	Returns the determinant of the Jacobian for `xi`, `eta` $\in [0,1]$ .
MapReal2d	jacobianInverse (const Real xi, const Real eta) const
	Returns the inverse of the Jacobian for `xi`, `eta` $\in [0,1]$ .
Level< 2 >	level () const
	Returns the level of the cell.
Real	lineElement (const Real xi, const uint edge) const
	Computes the differential element on an edge.
const MappingQuad2d *	map () const
	Returns the stored element map (same for all family related to one ancestor).
	Quad2d (Quad &cntr, const MappingQuad2d &map)
	Constructor.
virtual void	setStrategy (const Quad2dSubdivision *strategy=0) throw (StrategyChange)
	Sets the subdivision strategy of this quad.
Real3d	vertex (uint i) const
	Returns the coordinates of the ith vertex.
virtual	~Quad2d ()
Protected Member Functions
Quad2d *	createChild_ (Quad &cntr, const Index &idx, bool flag) const
	Non-virtual form of the private createChild_() method.
virtual std::ostream &	info (std::ostream &os) const
	Returns information in an output stream.
	Quad2d (Quad &cntr, MappingQuad2d *map, const Index &idx)
	Private constructor.
Protected Attributes
Index	idx_
	Index of this element.
MappingQuad2d *	map_
	Pointer to the element map.
Private Member Functions
virtual Quad2d *	createChild_ (Quad &cntr, const Index &idx) const
	Creates and returns a child.
Quad2d &	operator= (const Quad2d &other)
	Quad2d (const Quad2d &other)
Private Attributes
Quad2d *	chld_
	Pointer to the first child.
Quad &	cntr_
	Reference to the quadrilateral connector (topology)
concepts::Array< Edge2d * >	edge_
Quad2d *	lnk_
	Pointer to a sibling.
const Quad2dSubdivision *	subdivStrategy_
	Subdivision strategy for the quadrilateral.
Friends
std::ostream &	operator<< (std::ostream &os, const Quad2d::Index &i)
class	Quad2dSubdiv2H
class	Quad2dSubdiv2V
class	Quad2dSubdiv4
class	Quad2dSubdivision

Detailed Description

A 2D cell: quadrilateral.

If a quad is subdivided, two or four new quads are created. This happens automatically, if a child is requested, depending on the strategy that has been set. If two or four children are created depends on the chosen strategy. The default strategy is the create four children.

The directions of the edges in the quadriateral on the coarsest level are externally defined, see Quad::rho(). The edges of quadrilaterals which are created by subdivision are always counter-clockwise.

See also:: Cell for more information on cells in a mesh.

Test:

test::TestJacobian2D

test::TestMatrices2D

Examples:: meshes.cc.

Definition at line 278 of file cell2D.hh.

Constructor & Destructor Documentation

concepts::Quad2d::Quad2d	(	Quad &	cntr,
		const MappingQuad2d &	map
	)

Constructor.

Takes the connector cntr and the element map map and creates a cell.

Parameters:

cntr	Topological information of the quadrilateral
map	Element map of the quadrilateral

virtual concepts::Quad2d::~Quad2d ( ) [virtual]

concepts::Quad2d::Quad2d ( const Quad2d & other ) [private]

concepts::Quad2d::Quad2d	(	Quad &	cntr,
		MappingQuad2d *	map,
		const Index &	idx
	)		`[protected]`

Private constructor.

Member Function Documentation

Real3d concepts::Quad2d::center ( ) const [inline, virtual]

Returns the center of the cell.

Implements concepts::Cell2.

Definition at line 432 of file cell2D.hh.

Here is the call graph for this function:

Real2d concepts::Quad2d::chi	(	Real	xi,
		Real	eta
	)		const

Evaluates the element map.

Maps a point from the the reference coordinates in [0,1]² onto the physical coordinates.

Returns:: Point in 2D in physical coordinates.

Parameters:

xi	$\in [0,1]$
eta	$\in [0,1]$

const Quad2d* concepts::Quad2d::child	(	uint	i,
		Real	xi,
		Real	eta,
		Real &	xiC,
		Real &	etaC
	)		const `[inline]`

Returns a child.

If not a valid children exist, none are created and 0 is returned.

Parameters:

i	Index of the child to be returned.
xi,eta	local coordinates, where the child is located
xiC,etaC	local coordinates in the child

Definition at line 345 of file cell2D.hh.

Here is the call graph for this function:

virtual Quad2d* concepts::Quad2d::child ( uint i ) [virtual]

Returns a child.

If no children exist, four new children are created. The quadrilateral is cut into four new quadrilaterals by joining the midpoints of its edges.

Parameters:

i	Index of the child to be returned.

Implements concepts::Cell2.

virtual const Quad2d* concepts::Quad2d::child ( uint i ) const [virtual]

Returns a child.

If no children exist, none are created and 0 is returned.

Parameters:

i	Index of the child to be returned.

Implements concepts::Cell2.

Quad2d* concepts::Quad2d::clone	(	Quad &	cntr,
		MappingQuad2d *	map
	)		const `[inline]`

Returns a copy of itself.

Definition at line 451 of file cell2D.hh.

Here is the call graph for this function:

Quad & concepts::Quad2d::connector ( ) const [inline, virtual]

Returns the quadrilateral connector (topology)

Implements concepts::Cell2.

Definition at line 518 of file cell2D.hh.

Quad2d* concepts::Quad2d::createChild_	(	Quad &	cntr,
		const Index &	idx,
		bool	flag
	)		const `[protected]`

Non-virtual form of the private createChild_() method.

Can be called by inheritated classes.

virtual Quad2d* concepts::Quad2d::createChild_	(	Quad &	cntr,
		const Index &	idx
	)		const `[private, virtual]`

Creates and returns a child.

Can only called by the object itself or friend classes. Its virtual, so that inheritated classes with additional properties can create a child of the same kind.

Reimplemented in concepts::ThinSheetQuad2d.

const MappingEdge2d* concepts::Quad2d::edgeMap ( uint edge ) const

Returns the mapping of an edge.

Construct an cell for an edge of quad with

				Edge2d edge(quad.connector(), quad.edgeMap(0));

The edgeMap can be useful for egde integrals in a 2D quadrilateral mesh.

Real3d concepts::Quad2d::elemMap ( const Real2d & coord_local ) const [inline, virtual]

Element map from point local coordinates in 2D.

Implements concepts::Cell2.

Definition at line 375 of file cell2D.hh.

Here is the call graph for this function:

virtual Real3d concepts::Cell2::elemMap ( const Real3d & coord_local ) const [inline, virtual, inherited]

Element map from point local coordinates in 3D.

Reference element is 2D, third component is omitted.

Reimplemented from concepts::Cell.

Definition at line 100 of file cell.hh.

Here is the call graph for this function:

virtual Real3d concepts::Cell::elemMap ( const Real coord_local ) const [virtual, inherited]

Element map from point local coordinates in 1D.

Reimplemented in concepts::Edge1d, and concepts::Edge2d.

const Quad2dSubdivision* concepts::Quad2d::getStrategy ( ) const [inline]

Returns the subdivision strategy of this quad.

If you want to find check against another strategy use

quad.getStrategy() == QuadSubdiv2V::instance()

Definition at line 474 of file cell2D.hh.

bool concepts::Quad2d::hasChildren ( ) const [inline]

Returns true if there is a least one child.

Reimplemented from concepts::Cell.

Definition at line 335 of file cell2D.hh.

virtual std::ostream& concepts::Quad2d::info ( std::ostream & os ) const [protected, virtual]

Returns information in an output stream.

Implements concepts::Cell.

Reimplemented in concepts::ThinSheetQuad2d.

MapReal2d concepts::Quad2d::jacobian	(	const Real	xi,
		const Real	eta
	)		const

Computes the Jacobian for xi, eta $\in [0,1]$ .

The Jacobian of a cell in the initial mesh is computed by the element map. The Jacobian of a subdivided cell is computed as follows. Let $H : \hat K \rightarrow \hat K'$ be the subdivision map in the reference coordinates (0,1)² and $F_K : \hat K \rightarrow K$ , $F_{K'} : \hat K \rightarrow K'$ the element maps of K and K' respectively. Then,

$F_K : \hat K' \rightarrow K' \quad \text{and} \quad F_K \circ H = F_{K'}.$

The subdivision map H in reference coordinates is

$H : \vec\xi \mapsto \begin{pmatrix} a & 0 \\ 0 & b \end{pmatrix} \vec \xi$

where $a = 2^{-l_0}$ , $b = 2^{-l_1}$ . $\vec l = (l_0, l_1)$ is the level of the cell with respect to the cell in the initial mesh. The derivative of H is $dH = \begin{pmatrix} a & 0 \\ 0 & b \end{pmatrix}$ .

Then, the Jacobian of $F_{K'}$ is

$dF_{K'} = dF_K \circ H \cdot dH.$

The part $dF_K \circ H$ (without H) is computed by the element map and the part $\cdot dH$ is computed in jacobian().

Real concepts::Quad2d::jacobianDeterminant	(	const Real	xi,
		const Real	eta
	)		const `[inline]`

Returns the determinant of the Jacobian for xi, eta $\in [0,1]$ .

Definition at line 413 of file cell2D.hh.

Here is the call graph for this function:

MapReal2d concepts::Quad2d::jacobianInverse	(	const Real	xi,
		const Real	eta
	)		const `[inline]`

Returns the inverse of the Jacobian for xi, eta $\in [0,1]$ .

Definition at line 406 of file cell2D.hh.

Here is the call graph for this function:

Level<2> concepts::Quad2d::level ( ) const [inline]

Returns the level of the cell.

The level describes the refinements in both directions with respect to the parent cell in the initial mesh. This level information is taken into account when evaluating the element map or the Jacobian.

Definition at line 429 of file cell2D.hh.

Real concepts::Quad2d::lineElement	(	const Real	xi,
		const uint	edge
	)		const

Computes the differential element on an edge.

xi stand for one of the variables

$\xi$

,

$\eta$

depending on the edge.

const MappingQuad2d* concepts::Quad2d::map ( ) const [inline]

Returns the stored element map (same for all family related to one ancestor).

Definition at line 437 of file cell2D.hh.

Quad2d& concepts::Quad2d::operator= ( const Quad2d & other ) [private]

virtual void concepts::Quad2d::setStrategy ( const Quad2dSubdivision * strategy = 0 ) throw (StrategyChange) [virtual]

Sets the subdivision strategy of this quad.

If the parameter is set to 0 (or if the method is called without parameter) the strategy is set to the default (if not already set). The default subdivision strategy is subdivision into 4 children.

Parameters:

strategy Pointer to an instance of a subdivision strategy.

Exceptions:

StrategyChange if the change is not allowed (the change is not allowed if there are children present or the topological strategy is set).

Real3d concepts::Quad2d::vertex ( uint i ) const [virtual]

Returns the coordinates of the ith vertex.

Implements concepts::Cell2.