OOF2: The Manual

2.5. Meshes and SubProblems
	Chapter 2. OOF2 Concepts

2.5. Meshes and SubProblems

The OOF2 Mesh object represents an actual finite element Mesh. It combines the geometry of a Skeleton with information about equations and boundary conditions, and it stores the values of Fields. Every Mesh is derived from a Skeleton. The Mesh elements have the same shape and position as the associated Skeleton elements. A single Skeleton may give rise to more than one Mesh.

2.5.1. SubProblems

A Mesh may be divided into a number of SubProblems, which can be solved independently. SubProblems may differ from one another geographically, by including different Elements. They may also differ in which Fields and Equations are defined on them. For example, you might want to solve one set of equations on particulate inclusions and another set on the matrix in which they're embedded. Or in a time dependent problem (coming soon), you might put the fast and slow degrees of freedom in separate subproblems and use different solution methods on each.

When a Mesh is created, a default SubProblem, called default, is created as well. The default SubProblem includes the entire Mesh. Users who don't need to use more complicated SubProblems can simply use the default, and can more or less forget that SubProblems exist at all. (Just think “mesh” when you read “subproblem” and you'll be fine.)

SubProblems are created in the Subproblem pane in the FE Mesh Task Page. The various kinds of SubProblems differ in their geographical extent. A MaterialSubProblem includes all Elements with a given Material type. A PixelGroupSubProblem includes all Elements which have a majority of their underlying pixels in a given PixelGroup. An EntireMeshSubProblem includes all Elements. There are also boolean SubProblems that are defined in terms of other existing SubProblems. The full set is documented in the CSubProblem class.

2.5.2. Fields

Fields are the quantities, such as Temperature and Displacement, that OOF2 solves for. Fields have values at all points of the SubProblem or SubProblems on which they are defined. The Fields Task Page in OOF2 is used to change the status of Fields.

A Field that is defined on a SubProblem has memory allocated to store its values at the nodes.
Values of a field that is active will be found when the SubProblem is solved. Only defined Fields can be activated.

If a Field is defined on two or more geographically overlapping SubProblems on a Mesh, then the Field's values are the same for each SubProblem whereever the SubProblems overlap. That is, although Fields are defined on SubProblems, their values are actually only stored on the Mesh.

OOF2 can handle scalar Fields (such as Temperature), vector Fields (such as Displacement), and even tensor fields^[3] (such as liquid crystal order parameters).

2.5.3. Fluxes

In OOF2 a Flux is a quantity analogous to stress in elasticity: it is generally some modulus times the derivative of a Field. Some examples are stress (elastic modulus times the strain, which is the symmetric gradient of the displacement), heat flux (thermal conductivity times the negative gradient of the temperature), and electrical polarization (permittivity times the negative gradient of the voltage). Properties define how Fields contribute to Fluxes. One flux may have contributions simultaneously from many different Properties and Fields.

Fluxes don't appear explicitly when setting up a problem, except when specifying Neumann or Generalized Force boundary conditions in the Boundary Condition page. After obtaining a solution, Fluxes may be computed for plots or analysis.

2.5.4. Removing The Third Dimension

OOF2 uses three dimensional material properties but only solves two dimensional problems. In elasticity, two standard ways of reducing three dimensional systems to two dimensions are plane strain and plane stress. Plane strain is implemented by constraining the out-of-plane components of the strain to be zero, and plane stress is (usually) implemented by using an effective in-plane elastic modulus.

OOF2 has to generalize the concepts of plane-stress and plane-strain because it deals with problems other than elasticity. Furthermore, since OOF2 allows couplings between Fields, more than one Field can contribute to a given Flux, and these couplings are not known in advance, it is not possible to compute effective in-plane moduli for generalized plane-stress problems.

OOF2's approach to the out-of-plane problem is to augment each Field with the out-of-plane components of its derivatives. For example, scalar Fields like Temperature become a pair of Fields, Temperature and Temperature_z, where Temperature_z is the z-derivative of the temperature. Displacement, which is a two-dimensional vector Field in the plane, is augmented with Displacement_z, which is the triplet of partial derivatives $$(\partial u_z/\partial x, \partial u_z/\partial y, \partial u_z/\partial z$)$ , where $u$ is the (three dimensional) displacement field. Then the generalization of plane-strain simply sets these out-of-plane derivatives to zero and excludes them from the solution process. This is done for Fields that are marked as in-plane in the Field task page. Note that Fields that are in-plane in one SubProblem must be in-plane in all SubProblems.

Plane-stress is generalized by augmenting the system of finite element equations by plane-flux equations that constrain the out-of-plane components of the Fluxes to be zero. This increases the size of the system of linear equations to be solved, but, unlike the method of defining effective in-plane moduli, works even if there are arbitrary couplings between fields.

2.5.5. Equations

Activating Equations in the Equations task page determines what physics problem OOF2 solves. There are (currently) two kinds of equations, divergence equations and plane-flux equations.

2.5.5.1. Divergence Equations

Divergence equations are of the form

$\nabla\cdot\mathrm{flux} = \mathrm{generalized\ applied\ force}$

(2.2)

The applied force comes from the boundary conditions. Examples are the force balance equation ( $\nabla\cdot\sigma = f$ ) and the heat equation ( $\nabla\cdot J = -\partial U/\partial t$ ).

2.5.5.2. Plane Flux Equations

Plane flux equations implement OOF2's generalization of plane-stress. They simply state that the out-of-plane components of some flux are zero. Examples are the plane-stress equation ( $\sigma_{iz}=0$ , $i=1,2,3$ ) and the plane-heat-flux equation ( $J_z = 0$ ).

Equations are activated and deactivated on SubProblems. When we say that a SubProblem is solved, we really mean that its active Equations are solved in the portion of the Mesh that is included in the SubProblem.

2.5.6. Boundary Conditions

OOF2 provides five kinds of boundary conditions, Dirichlet, Neumann, Floating, Generalized Force and Periodic. They can be applied only at boundaries that have been defined in the Skeleton from which the Mesh was derived. The Fields and Equations referred to in the boundary conditions need to be active.

The Boundary Conditions Task Page contains the GUI for constructing and manipulating boundary conditions. The underlying commands are in the OOF.Mesh.Boundary_Conditions menu. The boundary condition objects themselves are in the BC class.

Boundary conditions may be explicitly enabled or disabled after they've been defined, using the On/Off button on the Boundary Conditions page. This allows you to switch back and forth easily to see the effects of different boundary conditions on a solution.

	Note
	If you are using non-trivial `SubProblems`, be careful about boundary conditions on edges between the `SubProblems`. A future version of OOF2 will have tools to make it easy to apply the correct boundary conditions. But in version 2.0.2 if you solve for a field in one region, you can get unexpected field gradients in neighboring elements.

2.5.6.1. Profiles

A Profile object describes the shape of a boundary condition. That is, a boundary condition fixes some quantity (a Field component, for example) on a boundary and the Profile of the boundary condition specifies how that quantity varies along the length of the boundary.

Profiles can be either created on-the-fly when boundary conditions are created, or can be created beforehand. Profiles created beforehand are given names, and can be saved and reused in many different boundary conditions. The OOF.Mesh.Profiles menu contains commands for managing the named Profiles.

2.5.7. Elements and Nodes

Mesh elements are analogous to Skeleton elements, but they contain more information. In particular, Mesh elements can perform finite element interpolation by means of shape functions. The shape functions form a basis for the expansion of functions on the mesh, just as the series $(1,\ x,\ x^2,\ x^3,\dots)$ forms a basis for the expansion of functions of a real number $x$ . That is, any function $f(r)$ , where $r$ is a point in the plane, can be approximated by the sum

$f(r) = \sum_i a_i\,N_i(r)$

(2.3)

where $N_i(r)$ is the i^th shapefunction and $a_i$ is its coefficient. In finite elements, the shape functions are defined so that

$N_i(r_i) = 1$

(2.4)

for some position $r_i$ , and

$N_i(r_j) = 0$

(2.5)

for all $i\ne j$ . Therefore, the coefficients are simply given by

$a_i = f(r_i).$

(2.6)

These special positions $r_i$ are called the nodes of the mesh.^[4] There are always nodes at the corners of an element, so the nodes of a Skeleton element always correspond to nodes of a Mesh element, but a Mesh element may have nodes along its edges or even in its interior.

The above equation means that a Field $f$ can be determined by specifying its values $f(x_i)$ only at the nodes. Thus we think of the Field values as living on the nodes of the mesh. The goal of a finite element solution is to find Field values at nodes.

Why did we bother to explain all this? OOF2 requires you to choose what kind of finite elements to use when creating a Mesh. Different types of elements differ in the shape functions that they provide and in the number and position of their nodes.

The polynomial order of the element shape functions determines the order of the interpolation within the element, and therefore affects the accuracy of the solution. (Fields computed with linear shape functions will be constrained to have constant gradients within elements, for example.) Because shape functions are 1 at one node and 0 at all others, the number of nodes along an element edge determines the order of the shape functions: an edge with nodes only at its endpoints must have linear shape functions, whereas an edge with nodes at its endpoints and one more in its interior must have quadratic shape functions.

There are actually three kinds of nodes: nodes used to store Field values (function nodes), nodes used to determine the element geometry (mapping nodes), and nodes used for both purposes. (Nodes determine element geometry by defining a mapping from a “master” element with a standard shape and position to the actual element. The mapping nodes of the master element are mapped to the nodes of the actual element, and all other points are mapped by using the mapping nodes' shape functions for interpolation. Non-linear mapping can produce elements with curved edges.) Elements with the same number of function and mapping nodes are called isoparametric. Elements with more function nodes than mapping nodes are called subparametric, and elements with more mapping nodes than function nodes are called superparametric.

Note

Currently, although OOF2 allows high-order iso- and superparametric elements with non-linear mapping and curved element edges, it actually doesn't do anything useful with them. This is because Mesh elements are created from Skeleton elements, and Skeleton elements all have straight edges. The positions of interior nodes are determined by linear interpolation between the corner nodes, so the non-linear mapping from master elements to actual elements is effectively linear.

2.5.8. Solving a Mesh

After a Mesh has been created, Fields have been defined and activated, equations have been activated and boundary conditions have been applied, the OOF.Solver.Solve command finds the values of the Fields at the nodes of the Mesh within a given SubProblem.

The solution of a finite element problem involves the construction and solution of a matrix equation:

$Ax=b$

(2.7)

where $A$ is the stiffness matrix, $x$ is a vector containing all of the unknown field values at the nodes of the mesh, and $b$ is a vector that depends on boundary conditions and body forces. OOF2 provides a number of linear solvers for solving the matrix equation. The matrix $A$ is usually sparse, meaning that most of its entries are zero. Direct matrix solution methods, such as Gaussian elimination, require storage for all entries of the matrix, including the zeros. To save memory, most of the solution techniques in OOF2 are iterative -- they don't require explicit storage for the zeros in the matrix, but instead of finding the solution directly they converge on it after a number of iterations. The iteration stops when the residual, $|Ax-b|$ , falls below a specified error tolerance.

The linear solvers are applied in different ways to different problems by objects in the Driver class. For simple static linear problems, a LinearDriver applies a LinearSolver directly. Problems in which the matrix $A$ or the right hand side $b$ depend on the unknowns $x$ are solved by the Newton-Raphson method, which applies a linear solver repeatedly to solve a non-linear problem. In both cases, the process is controlled by an appropriate Driver object. (A driver for time dependent problems will be added shortly.)

2.5.9. Outputs

After solving a Mesh, it's possible to view the resulting Fields and other quantities that depend on them. These quantities are generically called Outputs, and are discussed in Section 6.3. Outputs can be plotted in contour plots (both plain and filled) in the graphics window, queried at single points with the data viewer in the Mesh Info toolbox in the graphics window, or sent through various analysis routines in the analysis page.

^[3] OOF2 can “handle” tensor fields in the sense that the infrastructure for doing so is present. There are currently no tensor fields implemented and no material properties that use them.

^[4] This an extremely simplified discussion. Please see a real finite element text book for the details.


2.4. Skeletons		2.6. File Formats

/* OOF home */ /* OOF2 home */ /* Send mail to the OOF Team */