OOF2: The Manual
Name
Element — Element class for finite element meshes
Synopses
C++ Synopsis
#include "engine/element.h"
class Element {const Material * material() const;
int nnodes() const;
int nfuncnodes() const;
int shapefun_degree() const;
int dshapefun_degree() const;
ElementNodeIterator node_iterator() const;
ElementMapNodeIterator mapnode_iterator() const;
ElementFuncNodeIterator funcnode_iterator() const;
ElementCornerNodeIterator cornernode_iterator() const;
MasterCoord to_master(const Coord& position) const;
Coord from_master(const MasterCoord& position) const;
MasterCoord center() const;
double area() const;
OutputValue outputField(const Field& field,
const MasterPosition& position) const;OutputValue outputFieldDeriv(const Field& field,
SpaceIndex* derivative,
const MasterPosition& position) const;OutputValue outputFlux(const FEMesh* mesh,
const Flux& flux,
const MasterPosition& position) const;
}
Python Synopsis
from oof2.SWIG.engine import element
class Element:def material(self)
def area(self)
def shapefun_degree(self)
def dshapefun_degree(self)
def node_iterator(self)
def mapnode_iterator(self)
def funcnode_iterator(self)
def cornernode_iterator(self)
def outputField(self, field, position)
def outputFlux(self, mesh, flux, position)
def from_master(self, x, y)
def to_master(self, x, y)
Description
Element
is a swigged C++ class for
describing a finite element. It is a generic class: each
Element
contains a pointer to a
MasterElement
object that contains all
of the geometry-specific details.
Only those parts of the Element
class
that are useful for writing OOF2 extensions are described
here. There are actually many more functions and data
members. Consult the source code for the details.
Methods
const Material* material() const
material
simply returns a pointer
to the Material
object that describes the Element
's
physical features.
int nfuncnodes() const
nfuncnodes
returns the number of
so-called function nodes
in the element. These are the nodes that store Field
values.
int shapefun_degree() const
shapefun_degree
returns the
polynomial degree of the Element
's
shape
functions, more or less. It actually returns the
Gaussian integration order required to perform integrals
over the Element
's area.
int dshapefun_degree() const
dshapefun_degree
returns the
Gaussian integration order required to integrate the
derivatives of the shape function over the area of the
Element
.
ElementNodeIterator node_iterator() const
node_iterator
returns an ElementNodeIterator
which can be used to access all of the
Element
's Nodes
.
ElementMapNodeIterator mapnode_iterator() const
mapnode_iterator
returns an ElementMapNodeIterator
which can be used to access all of the
Element
's mapping Nodes
.
These are the Nodes
that determine
the Element
's shape and position in
space. That is, they determine the
mapping between master coordinates and
physical coordinates.
ElementFuncNodeIterator funcnode_iterator() const
funcnode_iterator
returns an ElementFuncNodeIterator
which can be used to access all of the
Element
's FuncNodes
.
FuncNodes
are Nodes
which store Field
values.
ElementCornerNodeIterator cornernode_iterator() const
cornernode_iterator
returns an
ElementCornerNodeIterator
which can be used to access the Nodes
at
the corners of the Element
.
MasterCoord to_master(const Coord&) const, to_master(x,y)
to_master
converts a position in
physical space to a position in the
Element
's master coordinate space.
The C++ version takes a Coord
argument, but the Python version takes two floats,
x
and y
, which allows
it to work equally well with Points
and swigged Coords
. Both versions
return a MasterCoord
object.
to_master
is a fairly expensive
function to compute, so it should be used judiciously.
Coord from_master(const MasterCoord&) const, from_master(x,y)
from_master
takes a position in
master coordinate space (in the form of a MasterCoord
object in C++ or an
x
,y
pair in Python)
and returns the corresponding point in physical space. The
return value is a Coord
in
both languages.
MasterCoord center() const
center
returns the position of the
center of the Element
in master coordinate space.
This can be converted to a physical coordinate with from_master
.
OutputValue outputField(const Field& field,
const MasterPosition& position) const
outputField
uses finite element
interpolation to evaluate a given Field
at
a given position
within the
Element
. The position must be
specified in the Element
's master coordinate space.
The value of the Field
is returned
inside a generic OutputValue
wrapper, allowing it to be used in the Outputs
.
OutputValue outputFieldDeriv(const Field& field,
SpaceIndex* derivative, const MasterPosition&
position)
\
outputFieldDeriv
is just like outputField
,
but it computes a derivative of the Field
.
The derivative
argument is a
SpaceIndex
object, which is basically
a fancy integer.[58]
outputFieldDeriv
returns the
x derivative if
derivative==0
and the y
derivative if derivative==1
.
OutputValue outputFlux(const FEMesh* mesh, const
Flux& flux, const MasterPosition& position) const
outputFlux
is just like outputField
,
except that it computes the value of a Flux
.
[58]
The wrapper around the integer provides type
checking. For example, it prevents a shape function
index from being used as a spatial index, although both
are integers. See
SRC/engine/indextypes.h
.
/* OOF home */ /* OOF2 home */ /* Send mail to the OOF Team */