FemFactory (Artisynth API documentation)

java.lang.Object
- artisynth.core.femmodels.FemFactory

public class FemFactory
extends java.lang.Object

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class FemFactory.FemElementType

static class FemFactory.FemShapingType

Nested Classes
Modifier and Type	Class and Description
`static class`	`FemFactory.FemElementType`
`static class`	`FemFactory.FemShapingType`

Constructor Summary

Constructors
Constructor and Description

FemFactory()

Constructors
Constructor and Description
`FemFactory()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`addFem(FemModel3d fem0, FemModel3d fem1)` Adds a copy of the nodes, elements, markers and attachments from `fem1` to `fem0`.
`static void`	`addFem(FemModel3d fem0, FemModel3d fem1, double nodeMergeDist)` Adds a copy of the nodes, elements, markers and attachments from `fem1` to `fem0`.
`static void`	`bilipschitzMapCylinderSphere(Point3d input, Point3d output)` Maps a cylinder with unit radius and z in [-1,1] to a unit sphere using the bilipschitz method described in A bi-Lipschitz continuous, volume preserving map from the unit ball onto a cube, Griepentrog, Hoppner, Kaiser, Rehberg, 2008
`static void`	`bilipschitzMapSphereCylinder(Point3d input, Point3d output)` Maps a unit sphere to a cylinder with unit radius and z in [-1,1] using the bilipschitz method described in A bi-Lipschitz continuous, volume preserving map from the unit ball onto a cube, Griepentrog, Hoppner, Kaiser, Rehberg, 2008
`static void`	`conformalMapEllipseRectangle(double a, double b, double L1, double L2, Point3d input, Point3d output)` Conformally maps an ellipse to a rectangular grid using the method of Daniela Rosca, Uniform and refinable grids on elliptic domains and on some surfaces of revolution, Applied Mathematics and Computation,Volume 217, Issue 19, 2011, Pages 7812-7817
`static void`	`conformalMapRectangleEllipse(double a, double b, double L1, double L2, Point3d input, Point3d output)` Conformally maps a rectangular grid to an ellipse using the method of Daniela Rosca, Uniform and refinable grids on elliptic domains and on some surfaces of revolution, Applied Mathematics and Computation,Volume 217, Issue 19, 2011, Pages 7812-7817
`static FemModel3d`	`createConformalHexCylinder(FemModel3d fem, double l, double r, int nl, int nr)` Creates a hex cylinder by first generating a hex grid, then mapping it to a cylinder using a conformal map
`static FemModel3d`	`createConformalHexEllipsoid(FemModel3d model, double rz, double rsx, double rsy, int nr)` Creates a hex ellipsoidal model by first creating a hex sphere using `createConformalHexSphere(artisynth.core.femmodels.FemModel3d, double, int)` and then scaling it.
`static FemModel3d`	`createConformalHexSphere(FemModel3d fem, double r, int nr)` Creates a hex sphere by first generating a regular grid, then mapping it to the sphere using a volume-preserving bi-lipschitz projection
`static FemModel3d`	`createCylinder(FemModel3d model, double l, double r, int nt, int nl, int nr)` Creates a cylinder made of mostly hex elements, with wedges in the centre column.
`static FemModel3d`	`createEllipsoid(FemModel3d model, double rl, double rs1, double rs2, int nt, int nl, int ns)` Creates an ellipsoidal model using a combination of hex, wedge, and tet elements.
`static FemModel3d`	`createExtrusion(FemModel3d model, FemFactory.FemElementType type, int n, double d, double zOffset, PolygonalMesh surface)` Creates a shell-based FEM model by extruding a surface mesh along the normal direction of its faces.
`static FemModel3d`	`createExtrusion(FemModel3d model, int n, double d, double zOffset, FemModel3d shellFem)` Creates a shell-type FEM model by extruding the shell elements of an existing surface mesh along the direction of the associated vertex normals.
`static FemModel3d`	`createExtrusion(FemModel3d model, int n, double d, double zOffset, PolygonalMesh surface)` Creates a shell-type FEM model by extruding a surface mesh along the normal direction of its faces.
`static FemModel3d`	`createFlattenedHexSphere(FemModel3d fem, double r, double rf, int nt)`
`static void`	`createFromElementList(FemModel3d out, java.util.Collection<FemElement3d> elemList)` Creates a new model by duplicating nodes and elements
`static FemModel3d`	`createFromMesh(FemModel3d model, PolygonalMesh surface, double quality)` Creates a tetrahedral FEM model from a triangular surface mesh.
`static FemModel3d`	`createFromMeshAndPoints(FemModel3d model, PolygonalMesh surface, double quality, Point3d[] pnts)` Constrained Delaunay, including the supplied list of points if they fall inside the surface
`static FemModel3d`	`createGrid(FemModel3d model, FemFactory.FemElementType type, double widthX, double widthY, double widthZ, int numX, int numY, int numZ)` Creates a regular grid, composed of elements of the type specified by `type`, centered on the origin, with specified widths and grid resolutions along each axis.
`static FemModel3d`	`createHexCylinder(FemModel3d fem, double h, double r, int nh, int nt)` Creates a hex cylinder centered on the origin with its central axis aligned with z.
`static FemModel3d`	`createHexEllipsoid(FemModel3d model, double rx, double ry, double rz, int nt)` Creates a hex ellipsoidal model by first creating a hex sphere using `createHexSphere(artisynth.core.femmodels.FemModel3d, double, int)` and then scaling it.
`static FemModel3d`	`createHexExtrusion(FemModel3d model, int n, double d, double zOffset, PolygonalMesh surface)` Creates a shell-based FEM model made of hex elements by extruding a surface mesh along the normal direction of its faces.
`static FemModel3d`	`createHexGrid(FemModel3d model, double widthX, double widthY, double widthZ, int numX, int numY, int numZ)` Creates a regular grid composed of hex elements.
`static FemModel3d`	`createHexSphere(FemModel3d fem, double r, int nt)` Creates a hex sphere by partitioning the sphere into seven regions: an inner block, surrounded by six symmetrical sections.
`static FemModel3d`	`createHexTorus(FemModel3d model, double R, double rin, double rout, int nt, int nl, int nr)` Creates a hollow torus made of hex elements.
`static FemModel3d`	`createHexTube(FemModel3d model, double l, double rin, double rout, int nt, int nl, int nr)` Creates a tube made of hex elements.
`static FemModel3d`	`createHexWedgeCylinder(FemModel3d model, double l, double r, int nt, int nl, int nr)` Creates a cylinder made of mostly hex elements, with wedges in the centre column.
`static FemModel3d`	`createHexWedgeExtrusion(FemModel3d model, int n, double d, double zOffset, PolygonalMesh surface, FemModel3d surfaceFem)` Creates a shell-based FEM model by extruding a surface mesh along the normal direction of its faces.
`static FemModel3d`	`createIcosahedralSphere(FemModel3d model, double r, int ndivisions, double quality)` Creates a tet-based spherical model based on a icosahedron.
`static FemModel3d`	`createPartialCylinder(FemModel3d model, double l, double r, double theta, int nl, int nr, int ntheta)` Creates a partial cylinder made of mostly hex elements, with wedges in the centre column
`static FemModel3d`	`createPartialHexTorus(FemModel3d model, double R, double rin, double rout, int nt, int nl, int nr, double theta)` Creates a hollow partial torus made of hex elements.
`static FemModel3d`	`createPartialHexTube(FemModel3d model, double l, double rin, double rout, double theta, int nl, int nr, int ntheta)` Creates a partial tube made of hex elements.
`static FemModel3d`	`createPartialHexWedgeCylinder(FemModel3d model, double l, double r, double theta, int nl, int nr, int ntheta)`
`static FemModel3d`	`createPartialTetTorus(FemModel3d model, double R, double rin, double rout, int nt, int nl, int nr, double theta)` Creates a partial torus made of tet elements.
`static FemModel3d`	`createPartialTetTube(FemModel3d model, double l, double rin, double rout, double theta, int nl, int nr, int ntheta)` Creates a partial tube made of tet elements.
`static FemModel3d`	`createPartialTube(FemModel3d model, FemFactory.FemElementType type, double l, double rin, double rout, double theta, int nl, int nr, int ntheta)` Creates a partial tube made of either tet or hex elements, as specified by `type`.
`static FemModel3d`	`createPolarSphere(FemModel3d model, double r, int nlat, int nlong, int nr)` Creates a fem model with tet, pyramid and hex elements by breaking the domain into spherical (3D polar) coordinates.
`static FemModel3d`	`createPyramidGrid(FemModel3d model, double widthX, double widthY, double widthZ, int numX, int numY, int numZ)` Creates a regular grid composed of pyramid elements.
`static FemModel3d`	`createQuadhexExtrusion(FemModel3d model, int n, double d, double zOffset, PolygonalMesh surface)` Creates a shell-based FEM model made of quadratic hex elements by extruding a surface mesh along the normal direction of its faces.
`static FemModel3d`	`createQuadhexGrid(FemModel3d model, double widthX, double widthY, double widthZ, int numX, int numY, int numZ)` Creates a regular grid composed of quadratic hex elements.
`static FemModel3d`	`createQuadhexTorus(FemModel3d model, double R, double rin, double rout, int nt, int nl, int nr)` Creates a hollow torus made of quadratic hex elements.
`static FemModel3d`	`createQuadhexTube(FemModel3d model, double l, double rin, double rout, int nt, int nl, int nr)` Creates a tube made of quadratic hex elements.
`static FemModel3d`	`createQuadpyramidGrid(FemModel3d model, double widthX, double widthY, double widthZ, int numX, int numY, int numZ)` Creates a regular grid composed of quadratic pyramid elements.
`static FemModel3d`	`createQuadraticModel(FemModel3d quadMod, FemModel3d linMod)` Takes a FemModel3d containing linear elements, and creates a quadratic model whose elements are the corresponding quadratic elements, with new nodes inserted along the edges as required.
`static FemModel3d`	`createQuadtetCylinder(FemModel3d model, double h, double r, int nh, int nr)` Creates a cylinder of quadratic tets, all with approximately uniform size
`static FemModel3d`	`createQuadtetCylinder(FemModel3d fem, double l, double r, int nt, int nl, int nr)` Creates a quadratic tetrahedral cylinder by tetrahedralizing a hex-wedge cylinder
`static FemModel3d`	`createQuadtetExtrusion(FemModel3d model, int n, double d, double zOffset, PolygonalMesh surface)` Creates a shell-based FEM model made of quadratic tet elements by extruding a surface mesh along the normal direction of its faces.
`static FemModel3d`	`createQuadtetGrid(FemModel3d model, double widthX, double widthY, double widthZ, int numX, int numY, int numZ)` Creates a regular grid composed of quadratic tet elements.
`static FemModel3d`	`createQuadtetSphere(FemModel3d model, double r, int nr)` Creates a sphere out of approximately uniform quadratic tets.
`static FemModel3d`	`createQuadtetTorus(FemModel3d model, double R, double rin, double rout, int nt, int nl, int nr)` Creates a hollow torus made of quadratic tet elements.
`static FemModel3d`	`createQuadtetTube(FemModel3d model, double l, double rin, double rout, int nt, int nl, int nr)` Creates a tube made of quadratic tet elements.
`static FemModel3d`	`createQuadwedgeExtrusion(FemModel3d model, int n, double d, double zOffset, PolygonalMesh surface)` Creates a shell-based FEM model made of quadratic wedge elements by extruding a surface mesh along the normal direction of its faces.
`static FemModel3d`	`createQuadwedgeGrid(FemModel3d model, double widthX, double widthY, double widthZ, int numX, int numY, int numZ)` Creates a regular grid composed of quadratic wedge elements.
`static FemModel3d`	`createRoundedDisc(FemModel3d fem, double h, double r, int nh, int nt)` Creates a hex-dominant disc with rounded edges, based on a hex cylinder, with additional hexes and wedges added to round off the surrounding edge.
`static FemModel3d`	`createRoundedHexWedgeDisc(FemModel3d fem, double h, double r, int nt, int nh, int nr)` Creates a disc with rounded edges using hex and wedge elements, based on a hex cylinder, with additional hexes and wedges added round off the surrounding edge.
`static FemModel3d`	`createShellGrid(FemModel3d model, FemFactory.FemElementType type, double widthX, double widthY, int numX, int numY, double thickness, boolean membrane)` Creates a regular grid of shell elements of the type specified by `type`, centered on the origin, with specified widths and grid resolutions along each axis.
`static FemModel3d`	`createShellModel(FemModel3d model, PolygonalMesh mesh, double thickness, boolean membrane)` Creates a shell model from an input mesh.
`static FemModel3d`	`createShellQuadGrid(FemModel3d model, double widthX, double widthY, int numX, int numY, double thickness, boolean membrane)` Creates a regular grid composed of shell quad elements.
`static FemModel3d`	`createShellTriGrid(FemModel3d model, double widthX, double widthY, int numX, int numY, double thickness, boolean membrane)` Creates a regular grid composed of shell triangle elements.
`static FemModel3d`	`createSphere(FemModel3d model, double r, int nt, int nl, int ns)` Convenience method to create a symmetric hex/wedge dominant sphere using `createEllipsoid(artisynth.core.femmodels.FemModel3d, double, double, double, int, int, int)`.
`static FemModel3d`	`createTetCylinder(FemModel3d model, double h, double r, int nh, int nr)` Creates a cylinder of tets, all with approximately uniform size
`static FemModel3d`	`createTetCylinder(FemModel3d fem, double l, double r, int nt, int nl, int nr)` Creates a tetrahedral cylinder by tetrahedralizing a hex-wedge cylinder
`static FemModel3d`	`createTetEllipsoid(FemModel3d model, double rz, double rsx, double rsy, int nr)` Creates a ellipsoidal model using a tet elements by first creating a tet sphere and then scaling it.
`static FemModel3d`	`createTetEllipsoid(FemModel3d model, double rl, double rs1, double rs2, int nt, int nl, int ns)` Creates an ellipsoidal model using tet elements.
`static FemModel3d`	`createTetExtrusion(FemModel3d model, int n, double d, double zOffset, PolygonalMesh surface)` Creates a shell-based FEM model made of tet elements by extruding a surface mesh along the normal direction of its faces.
`static FemModel3d`	`createTetGrid(FemModel3d model, double widthX, double widthY, double widthZ, int numX, int numY, int numZ)` Creates a regular grid composed of tet elements.
`static FemModel3d`	`createTetSphere(FemModel3d model, double r, int nr)` Creates a sphere out of approximately uniform tets.
`static FemModel3d`	`createTetTorus(FemModel3d model, double R, double rin, double rout, int nt, int nl, int nr)` Creates a torus made of tet elements.
`static FemModel3d`	`createTetTube(FemModel3d model, double l, double rin, double rout, int nt, int nl, int nr)` Creates a tube made of tet elements.
`static FemModel3d`	`createTorus(FemModel3d model, FemFactory.FemElementType type, double R, double rin, double rout, int nt, int nl, int nr)` Creates a hollow torus made of either tet, hex, quadTet, or quadHex elements, as specified by `type`.
`static FemModel3d`	`createTube(FemModel3d model, FemFactory.FemElementType type, double l, double rin, double rout, int nt, int nl, int nr)` Creates a tube made of either tet, hex, quadTet, or quadHex elements, as specified by `type`.
`static FemModel3d`	`createWedgeCylinder(FemModel3d model, double h, double r, int nh, int nr)` Creates a cylinder made entirely of wedges, all approximately uniform in size
`static FemModel3d`	`createWedgeExtrusion(FemModel3d model, int n, double d, double zOffset, PolygonalMesh surface)` Creates a shell-based FEM model made of wedge elements by extruding a surface mesh along the normal direction of its faces.
`static FemModel3d`	`createWedgeGrid(FemModel3d model, double widthX, double widthY, double widthZ, int numX, int numY, int numZ)` Creates a regular grid composed of wedge elements.
`static void`	`mapCubeToSphere(Point3d cube, Point3d sphere)` Maps a 2x2x2 cube to a unit sphere
`static void`	`mapSphereToCube(Point3d sphere, Point3d cube)` Maps a unit sphere to a 2x2x2 cube
`static FemModel3d`	`mergeCollapsedNodes(FemModel3d model, FemModel3d orig, double epsilon)`
`static FemModel3d`	`refineFem(FemModel3d model, FemModel3d input, double quality)` Creates a refined version of a an existing tetrahedral FEM model using tetgen.
`static FemModel3d`	`refineFem(FemModel3d model, FemModel3d input, double quality, Point3d[] pnts)` Creates a refined version of a an existing tetrahedral FEM model using tetgen and a list of supplemental node locations.
`static void`	`setPlanarNodesFixed(FemModel fem, Point3d center, Vector3d normal, boolean fixed)`
`static FemModel3d`	`subdivideFem(FemModel3d femr, FemModel3d fem0)` Creates a subdvided FEM model by subdividing all the elements of an existing model into eight sub-elements, adding additional nodes as required.
`static FemModel3d`	`subdivideFem(FemModel3d femr, FemModel3d fem0, boolean addMarkers)`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - FemFactory
```
public FemFactory()
```
- Method Detail
  - createTetGrid
```
public static FemModel3d createTetGrid(FemModel3d model,
                                       double widthX,
                                       double widthY,
                                       double widthZ,
                                       int numX,
                                       int numY,
                                       int numZ)
```
    Creates a regular grid composed of tet elements. Identical to createGrid(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.Tet.
  - createPyramidGrid
```
public static FemModel3d createPyramidGrid(FemModel3d model,
                                           double widthX,
                                           double widthY,
                                           double widthZ,
                                           int numX,
                                           int numY,
                                           int numZ)
```
    Creates a regular grid composed of pyramid elements. Identical to createGrid(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.Pyramid.
  - createHexGrid
```
public static FemModel3d createHexGrid(FemModel3d model,
                                       double widthX,
                                       double widthY,
                                       double widthZ,
                                       int numX,
                                       int numY,
                                       int numZ)
```
    Creates a regular grid composed of hex elements. Identical to createGrid(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.Hex.
  - createWedgeGrid
```
public static FemModel3d createWedgeGrid(FemModel3d model,
                                         double widthX,
                                         double widthY,
                                         double widthZ,
                                         int numX,
                                         int numY,
                                         int numZ)
```
    Creates a regular grid composed of wedge elements. Identical to createGrid(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.Wedge.
  - createQuadtetGrid
```
public static FemModel3d createQuadtetGrid(FemModel3d model,
                                           double widthX,
                                           double widthY,
                                           double widthZ,
                                           int numX,
                                           int numY,
                                           int numZ)
```
    Creates a regular grid composed of quadratic tet elements. Identical to createGrid(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.QuadTet.
  - createQuadhexGrid
```
public static FemModel3d createQuadhexGrid(FemModel3d model,
                                           double widthX,
                                           double widthY,
                                           double widthZ,
                                           int numX,
                                           int numY,
                                           int numZ)
```
    Creates a regular grid composed of quadratic hex elements. Identical to createGrid(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.QuadHex.
  - createQuadwedgeGrid
```
public static FemModel3d createQuadwedgeGrid(FemModel3d model,
                                             double widthX,
                                             double widthY,
                                             double widthZ,
                                             int numX,
                                             int numY,
                                             int numZ)
```
    Creates a regular grid composed of quadratic wedge elements. Identical to createGrid(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.QuadWedge.
  - createQuadpyramidGrid
```
public static FemModel3d createQuadpyramidGrid(FemModel3d model,
                                               double widthX,
                                               double widthY,
                                               double widthZ,
                                               int numX,
                                               int numY,
                                               int numZ)
```
    Creates a regular grid composed of quadratic pyramid elements. Identical to createGrid(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.QuadPyramid.
  - createGrid
```
public static FemModel3d createGrid(FemModel3d model,
                                    FemFactory.FemElementType type,
                                    double widthX,
                                    double widthY,
                                    double widthZ,
                                    int numX,
                                    int numY,
                                    int numZ)
```
    Creates a regular grid, composed of elements of the type specified by type, centered on the origin, with specified widths and grid resolutions along each axis.
    
    Parameters:
    
    model - model to which the elements be added, or null if the model is to be created from scratch.
    
    type - desired element type
    
    widthX - x axis model width
    
    widthY - y axis model width
    
    widthZ - z axis model width
    
    numX - element resolution along the x axis
    
    numY - element resolution along the y axis
    
    numZ - element resolution along the z axis
    
    Returns:
    
    created FEM model
    
    Throws:
    
    java.lang.IllegalArgumentException - if the specified element type is not supported
  - createShellTriGrid
```
public static FemModel3d createShellTriGrid(FemModel3d model,
                                            double widthX,
                                            double widthY,
                                            int numX,
                                            int numY,
                                            double thickness,
                                            boolean membrane)
```
    Creates a regular grid composed of shell triangle elements. Identical to createShellGrid(FemModel3d,FemElementType,double,double,int,int,double, boolean) with the element type set to FemFactory.FemElementType.ShellTri.
  - createShellModel
```
public static FemModel3d createShellModel(FemModel3d model,
                                          PolygonalMesh mesh,
                                          double thickness,
                                          boolean membrane)
```
    Creates a shell model from an input mesh. The mesh must contain either triangle or quad elements.
  - createShellQuadGrid
```
public static FemModel3d createShellQuadGrid(FemModel3d model,
                                             double widthX,
                                             double widthY,
                                             int numX,
                                             int numY,
                                             double thickness,
                                             boolean membrane)
```
    Creates a regular grid composed of shell quad elements. Identical to createShellGrid(FemModel3d,FemElementType,double,double,int,int,double, boolean) with the element type set to FemFactory.FemElementType.ShellQuad.
  - createShellGrid
```
public static FemModel3d createShellGrid(FemModel3d model,
                                         FemFactory.FemElementType type,
                                         double widthX,
                                         double widthY,
                                         int numX,
                                         int numY,
                                         double thickness,
                                         boolean membrane)
```
    Creates a regular grid of shell elements of the type specified by type, centered on the origin, with specified widths and grid resolutions along each axis.
    
    Parameters:
    
    model - model to which the elements be added, or null if the model is to be created from scratch.
    
    type - desired element type
    
    widthX - x axis model width
    
    widthY - y axis model width
    
    numX - element resolution along the x axis
    
    numY - element resolution along the y axis
    
    thickness - element rest thickness
    
    membrane - if true, defined the elements to to be membrane elements
    
    Returns:
    
    created FEM model
    
    Throws:
    
    java.lang.IllegalArgumentException - if the specified element type is not supported or is not an shell element
  - mergeCollapsedNodes
```
public static FemModel3d mergeCollapsedNodes(FemModel3d model,
                                             FemModel3d orig,
                                             double epsilon)
```
  - createIcosahedralSphere
```
public static FemModel3d createIcosahedralSphere(FemModel3d model,
                                                 double r,
                                                 int ndivisions,
                                                 double quality)
```
    Creates a tet-based spherical model based on a icosahedron. The method works by creating an icosahedral surface mesh and then using tetgen.
    
    Parameters:
    
    model - empty FEM model to which elements are added; if null then a new model is allocated
    
    r - radius
    
    ndivisions - number of divisions used in creating the surface mesh. Typical values are 1 or 2.
    
    quality - quality parameter passed to tetgen. See createFromMesh(artisynth.core.femmodels.FemModel3d, maspack.geometry.PolygonalMesh, double) for a full description.
    
    Returns:
    
    the FEM model (which will be model if model is not null).
  - createPolarSphere
```
public static FemModel3d createPolarSphere(FemModel3d model,
                                           double r,
                                           int nlat,
                                           int nlong,
                                           int nr)
```
    Creates a fem model with tet, pyramid and hex elements by breaking the domain into spherical (3D polar) coordinates. The radius is adjusted geometrically so that elements maintain equal proportions
    
    Parameters:
    
    model - model to populate, null to create one
    
    r - radius of sphere
    
    nlat - number of latitude divisions (not including 0)
    
    nlong - number of longitude divisions
    
    nr - number of radial divisions (not including 0)
    
    Returns:
    
    populated or created model
  - createSphere
```
public static FemModel3d createSphere(FemModel3d model,
                                      double r,
                                      int nt,
                                      int nl,
                                      int ns)
```
    Convenience method to create a symmetric hex/wedge dominant sphere using createEllipsoid(artisynth.core.femmodels.FemModel3d, double, double, double, int, int, int).
    
    Parameters:
    
    model - empty FEM model to which elements are added; if null then a new model is allocated
    
    r - radius
    
    nt - number of nodes in each ring parallel to the equator
    
    nl - number of nodes in each quarter ring perpendicular to the equator (including end nodes)
    
    ns - number of nodes in each radial line extending out from the polar axis (including end nodes)
    
    Returns:
    
    the FEM model (which will be model if model is not null).
  - createTetSphere
```
public static FemModel3d createTetSphere(FemModel3d model,
                                         double r,
                                         int nr)
```
    Creates a sphere out of approximately uniform tets. This is accomplished by separating the sphere into a hexagonal prism with hexagonal pyramid caps, dividing each edge into k segments for the kth radius, and connecting the layers with patterns of tets.
    
    Parameters:
    
    model - model to populate, created if null
    
    r - radius of sphere
    
    nr - number of layers
    
    Returns:
    
    populated or created model
  - createQuadtetSphere
```
public static FemModel3d createQuadtetSphere(FemModel3d model,
                                             double r,
                                             int nr)
```
    Creates a sphere out of approximately uniform quadratic tets. This is accomplished by separating the sphere into a hexagonal prism with hexagonal pyramid caps, dividing each edge into k segments for the kth radius, and connecting the layers with patterns of tets.
    
    Parameters:
    
    model - model to populate, created if null
    
    r - radius of sphere
    
    nr - number of layers
    
    Returns:
    
    populated or created model
  - createConformalHexSphere
```
public static FemModel3d createConformalHexSphere(FemModel3d fem,
                                                  double r,
                                                  int nr)
```
    Creates a hex sphere by first generating a regular grid, then mapping it to the sphere using a volume-preserving bi-lipschitz projection
    
    Parameters:
    
    fem - model to populate
    
    r - radius
    
    nr - number of elements radially along each axis from the sphere center
    
    Returns:
    
    populated model
  - createHexSphere
```
public static FemModel3d createHexSphere(FemModel3d fem,
                                         double r,
                                         int nt)
```
    Creates a hex sphere by partitioning the sphere into seven regions: an inner block, surrounded by six symmetrical sections.
    
    Parameters:
    
    fem - model to which the elements should be added, or null if the model is to be created from scratch
    
    r - sphere radius
    
    nt - number of elements around the circumference. Will be rounded up to an even multiple of 4.
    
    Returns:
    
    created FEM model
  - createFlattenedHexSphere
```
public static FemModel3d createFlattenedHexSphere(FemModel3d fem,
                                                  double r,
                                                  double rf,
                                                  int nt)
```
  - createEllipsoid
```
public static FemModel3d createEllipsoid(FemModel3d model,
                                         double rl,
                                         double rs1,
                                         double rs2,
                                         int nt,
                                         int nl,
                                         int ns)
```
    Creates an ellipsoidal model using a combination of hex, wedge, and tet elements. The model is created symmetrically about a central polar axis, using wedge elements at the core. rl should be the longest radius, and corresponds to the polar axis.
    
    Parameters:
    
    model - empty FEM model to which elements are added; if null then a new model is allocated
    
    rl - longest radius (also the polar radius)
    
    rs1 - first radius perpendicular to the polar axis
    
    rs2 - second radius perpendicular to the polar axis
    
    nt - number of nodes in each ring parallel to the equator
    
    nl - number of nodes in each quarter ring perpendicular to the equator (including end nodes)
    
    ns - number of nodes in each radial line extending out from the polar axis (including end nodes)
    
    Returns:
    
    the FEM model (which will be model if model is not null).
  - createTetEllipsoid
```
public static FemModel3d createTetEllipsoid(FemModel3d model,
                                            double rl,
                                            double rs1,
                                            double rs2,
                                            int nt,
                                            int nl,
                                            int ns)
```
    Creates an ellipsoidal model using tet elements. The model is created symmetrically about a central polar axis, using tesselated wedge elements at the core. rl should be the longest radius, and corresponds to the polar axis.
    
    Parameters:
    
    model - empty FEM model to which elements are added; if null then a new model is allocated
    
    rl - longest radius (also the polar radius)
    
    rs1 - first radius perpendicular to the polar axis
    
    rs2 - second radius perpendicular to the polar axis
    
    nt - number of nodes in each ring parallel to the equator (will be rounded up to an even number)
    
    nl - number of nodes in each quarter ring perpendicular to the equator (including end nodes)
    
    ns - number of nodes in each radial line extending out from the polar axis (including end nodes)
    
    Returns:
    
    the FEM model (which will be model if model is not null).
  - createConformalHexEllipsoid
```
public static FemModel3d createConformalHexEllipsoid(FemModel3d model,
                                                     double rz,
                                                     double rsx,
                                                     double rsy,
                                                     int nr)
```
    Creates a hex ellipsoidal model by first creating a hex sphere using createConformalHexSphere(artisynth.core.femmodels.FemModel3d, double, int) and then scaling it.
    
    Parameters:
    
    model - empty FEM model to which elements are added; if null then a new model is allocated
    
    rz - longest radius (also the polar radius)
    
    rsx - first radius perpendicular to the polar axis
    
    rsy - second radius perpendicular to the polar axis
    
    nr - number of nodes in each radial line extending out from the polar axis (including end nodes)
    
    Returns:
    
    the FEM model (which will be model if model is not null).
  - createHexEllipsoid
```
public static FemModel3d createHexEllipsoid(FemModel3d model,
                                            double rx,
                                            double ry,
                                            double rz,
                                            int nt)
```
    Creates a hex ellipsoidal model by first creating a hex sphere using createHexSphere(artisynth.core.femmodels.FemModel3d, double, int) and then scaling it.
    
    Parameters:
    
    model - empty FEM model to which elements are added; if null then a new model is allocated
    
    rx - radius along x
    
    ry - radius along y
    
    rz - radius along z
    
    nt - number of elements around the circumference. Will be rounded up to an even multiple of 4.
    
    Returns:
    
    created FEM model
  - createTetEllipsoid
```
public static FemModel3d createTetEllipsoid(FemModel3d model,
                                            double rz,
                                            double rsx,
                                            double rsy,
                                            int nr)
```
    Creates a ellipsoidal model using a tet elements by first creating a tet sphere and then scaling it.
    
    Parameters:
    
    model - empty FEM model to which elements are added; if null then a new model is allocated
    
    rz - longest radius (also the polar radius)
    
    rsx - first radius perpendicular to the polar axis
    
    rsy - second radius perpendicular to the polar axis
    
    nr - number of nodes in each radial line extending out from the polar axis (including end nodes)
    
    Returns:
    
    the FEM model (which will be model if model is not null).
  - createCylinder
```
public static FemModel3d createCylinder(FemModel3d model,
                                        double l,
                                        double r,
                                        int nt,
                                        int nl,
                                        int nr)
```
    Creates a cylinder made of mostly hex elements, with wedges in the centre column.
    
    Parameters:
    
    model - model to which the elements should be added, or null if the model is to be created from scratch.
    
    l - length along the z axis
    
    r - radius in the x-y plane
    
    nt - element resolution around the center axis
    
    nl - element resolution along the length
    
    nr - element resolution along the radius
    
    Returns:
    
    created FEM model
  - createRoundedHexWedgeDisc
```
public static FemModel3d createRoundedHexWedgeDisc(FemModel3d fem,
                                                   double h,
                                                   double r,
                                                   int nt,
                                                   int nh,
                                                   int nr)
```
    Creates a disc with rounded edges using hex and wedge elements, based on a hex cylinder, with additional hexes and wedges added round off the surrounding edge. The disc is centered at the origin with its axis of symmetry parallel to the z axis. The dimensions are specified by the radius r of the flat portion of the disc, and a height h. The rounding radius at the edhe h/2, so that the total radius about z is r + h/2.
    One disadvantage of this meshing method is that the element density increases towards the center of the disc, culminating in a small inner disc composed of wedges. The method createRoundedDisc(artisynth.core.femmodels.FemModel3d, double, double, int, int) improves on this by replacing the central disc of wedges with a regular hex grid.
    
    Parameters:
    
    fem - model to which the elements should be added, or null if the model is to be created from scratch.
    
    h - height along the z axis
    
    r - radius of the flat part of the disc
    
    nh - number of elements along the z-axis, as seen through an interior cross section. Will be rounded up to an even number. The number of rounding elements used to wrap around the edge in a radial direction will also be based on this value.
    
    nt - number of elements around the circumference. Will be rounded up to be at least 3.
    
    nr - number of elements along the flat radius. Will be rounded up to at least 1.
    
    Returns:
    
    created FEM model
  - createRoundedDisc
```
public static FemModel3d createRoundedDisc(FemModel3d fem,
                                           double h,
                                           double r,
                                           int nh,
                                           int nt)
```
    Creates a hex-dominant disc with rounded edges, based on a hex cylinder, with additional hexes and wedges added to round off the surrounding edge. The disc is centered at the origin with its axis of symmetry parallel to the z axis. The dimensions are specified by the radius r of the flat portion of the disc, and a height h. The rounding radius at the edge is h/2, so that the total radius about z is r + h/2.
    The mesh created by this method is best behaved when h <= r. As h increases beyond r, the regular hex grid in the center will become quite small and dense, and so alternative mesh formulations may be preferable in such circumstances.
    
    Parameters:
    
    fem - model to which the elements should be added, or null if the model is to be created from scratch.
    
    h - height along the z axis
    
    r - radius of the flat part of the disc
    
    nh - number of elements along the z-axis, as seen through an interior cross section. Will be rounded up to an even number. The number of rounding elements used to wrap around the edge in a radial direction will also be based on this value.
    
    nt - number of elements around the circumference. Will be rounded up to an even multiple of 4.
    
    Returns:
    
    created FEM model
  - createHexWedgeCylinder
```
public static FemModel3d createHexWedgeCylinder(FemModel3d model,
                                                double l,
                                                double r,
                                                int nt,
                                                int nl,
                                                int nr)
```
    Creates a cylinder made of mostly hex elements, with wedges in the centre column. Identical to createCylinder(FemModel3d,double,double,int,int,int).
  - createTetCylinder
```
public static FemModel3d createTetCylinder(FemModel3d fem,
                                           double l,
                                           double r,
                                           int nt,
                                           int nl,
                                           int nr)
```
    Creates a tetrahedral cylinder by tetrahedralizing a hex-wedge cylinder
    
    Parameters:
    
    fem - model to populate
    
    l - length of cylinder (z-axis)
    
    r - radius of cylinder
    
    nt - number of elements around the arc (will be rounded up to an even number)
    
    nl - number of elements along the length
    
    nr - number of elements radially
    
    Returns:
    
    populated model
  - createQuadtetCylinder
```
public static FemModel3d createQuadtetCylinder(FemModel3d fem,
                                               double l,
                                               double r,
                                               int nt,
                                               int nl,
                                               int nr)
```
    Creates a quadratic tetrahedral cylinder by tetrahedralizing a hex-wedge cylinder
    
    Parameters:
    
    fem - model to populate
    
    l - length of cylinder (z-axis)
    
    r - radius of cylinder
    
    nt - number of elements around the arc
    
    nl - number of elements along the length
    
    nr - number of elements radially
    
    Returns:
    
    populated model
  - createWedgeCylinder
```
public static FemModel3d createWedgeCylinder(FemModel3d model,
                                             double h,
                                             double r,
                                             int nh,
                                             int nr)
```
    Creates a cylinder made entirely of wedges, all approximately uniform in size
    
    Parameters:
    
    model - model to populate, created if null
    
    h - height of cylinder (z-axis)
    
    r - radius of cylinder
    
    nh - element resolution in z
    
    nr - radial element resolution
    
    Returns:
    
    populated or created model
  - createTetCylinder
```
public static FemModel3d createTetCylinder(FemModel3d model,
                                           double h,
                                           double r,
                                           int nh,
                                           int nr)
```
    Creates a cylinder of tets, all with approximately uniform size
    
    Parameters:
    
    model - model to populate (if null, one is created)
    
    h - height of cylinder
    
    r - radius of cylinder
    
    nh - element resolution along height
    
    nr - radial element resolution
    
    Returns:
    
    populated or created model
  - createQuadtetCylinder
```
public static FemModel3d createQuadtetCylinder(FemModel3d model,
                                               double h,
                                               double r,
                                               int nh,
                                               int nr)
```
    Creates a cylinder of quadratic tets, all with approximately uniform size
    
    Parameters:
    
    model - model to populate (if null, one is created)
    
    h - height of cylinder
    
    r - radius of cylinder
    
    nh - element resolution along height
    
    nr - radial element resolution
    
    Returns:
    
    populated or created model
  - conformalMapEllipseRectangle
```
public static void conformalMapEllipseRectangle(double a,
                                                double b,
                                                double L1,
                                                double L2,
                                                Point3d input,
                                                Point3d output)
```
    Conformally maps an ellipse to a rectangular grid using the method of
    Daniela Rosca, Uniform and refinable grids on elliptic domains and on some surfaces of revolution, Applied Mathematics and Computation,Volume 217, Issue 19, 2011, Pages 7812-7817
    
    Parameters:
    
    a - ellipsoid radius along x
    
    b - ellipsoid radius along y
    
    L1 - rectangle half-width along x
    
    L2 - rectangle half-width along y
    
    input - input point (x,y)
    
    output - output point (x,y) modified, z left unchanged
  - conformalMapRectangleEllipse
```
public static void conformalMapRectangleEllipse(double a,
                                                double b,
                                                double L1,
                                                double L2,
                                                Point3d input,
                                                Point3d output)
```
    Conformally maps a rectangular grid to an ellipse using the method of
    Daniela Rosca, Uniform and refinable grids on elliptic domains and on some surfaces of revolution, Applied Mathematics and Computation,Volume 217, Issue 19, 2011, Pages 7812-7817
    
    Parameters:
    
    a - ellipsoid radius along x
    
    b - ellipsoid radius along y
    
    L1 - rectangle half-width along x
    
    L2 - rectangle half-width along y
    
    input - input point using (x,y)
    
    output - output point, only x,y are modified
  - bilipschitzMapSphereCylinder
```
public static void bilipschitzMapSphereCylinder(Point3d input,
                                                Point3d output)
```
    Maps a unit sphere to a cylinder with unit radius and z in [-1,1] using the bilipschitz method described in
    A bi-Lipschitz continuous, volume preserving map from the unit ball onto a cube, Griepentrog, Hoppner, Kaiser, Rehberg, 2008
    
    Parameters:
    
    input - sphere input point
    
    output - cylinder input point
  - bilipschitzMapCylinderSphere
```
public static void bilipschitzMapCylinderSphere(Point3d input,
                                                Point3d output)
```
    Maps a cylinder with unit radius and z in [-1,1] to a unit sphere using the bilipschitz method described in
    A bi-Lipschitz continuous, volume preserving map from the unit ball onto a cube, Griepentrog, Hoppner, Kaiser, Rehberg, 2008
    
    Parameters:
    
    input - cylinder input point
    
    output - sphere output point
  - mapCubeToSphere
```
public static void mapCubeToSphere(Point3d cube,
                                   Point3d sphere)
```
    Maps a 2x2x2 cube to a unit sphere
    
    Parameters:
    
    cube - input point in cube coordinates
    
    sphere - output point in sphere coordinates
  - mapSphereToCube
```
public static void mapSphereToCube(Point3d sphere,
                                   Point3d cube)
```
    Maps a unit sphere to a 2x2x2 cube
    
    Parameters:
    
    sphere - input point in sphere coordinates
    
    cube - output point in cube coordinates
  - createConformalHexCylinder
```
public static FemModel3d createConformalHexCylinder(FemModel3d fem,
                                                    double l,
                                                    double r,
                                                    int nl,
                                                    int nr)
```
    Creates a hex cylinder by first generating a hex grid, then mapping it to a cylinder using a conformal map
    
    Parameters:
    
    fem - model
    
    l - length of cylinder (z-axis)
    
    r - radius of cylinder
    
    nl - number of elements along the length
    
    nr - number of elements outward from the radius along the x,y-axes
    
    Returns:
    
    generated model
  - createHexCylinder
```
public static FemModel3d createHexCylinder(FemModel3d fem,
                                           double h,
                                           double r,
                                           int nh,
                                           int nt)
```
    Creates a hex cylinder centered on the origin with its central axis aligned with z. Hex meshing is accomplished by partitioning the volume into five regions: an inner block and four surrounding sections.
    
    Parameters:
    
    fem - model to which the elements should be added, or null if the model is to be created from scratch
    
    h - height the along z axis
    
    r - cylinder radius
    
    nh - number of elements along the height
    
    nt - number of elements around the circumference. Will be rounded up to an even multiple of 4.
    
    Returns:
    
    created FEM model
  - createPartialCylinder
```
public static FemModel3d createPartialCylinder(FemModel3d model,
                                               double l,
                                               double r,
                                               double theta,
                                               int nl,
                                               int nr,
                                               int ntheta)
```
    Creates a partial cylinder made of mostly hex elements, with wedges in the centre column
    
    Parameters:
    
    model - model to which the elements should be added, or null if the model is to be created from scratch.
    
    l - length along the z axis
    
    r - radius in the x-y plane
    
    theta - size of the slice, in radians
    
    nl - element resolution along the length
    
    nr - element resolution along the radius
    
    ntheta - element resolution around the slice
    
    Returns:
    
    created FEM model
  - createPartialHexWedgeCylinder
```
public static FemModel3d createPartialHexWedgeCylinder(FemModel3d model,
                                                       double l,
                                                       double r,
                                                       double theta,
                                                       int nl,
                                                       int nr,
                                                       int ntheta)
```
  - createHexTube
```
public static FemModel3d createHexTube(FemModel3d model,
                                       double l,
                                       double rin,
                                       double rout,
                                       int nt,
                                       int nl,
                                       int nr)
```
    Creates a tube made of hex elements. Identical to createTube(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.Hex.
  - createTetTube
```
public static FemModel3d createTetTube(FemModel3d model,
                                       double l,
                                       double rin,
                                       double rout,
                                       int nt,
                                       int nl,
                                       int nr)
```
    Creates a tube made of tet elements. Identical to createTube(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.Tet.
  - createPartialHexTube
```
public static FemModel3d createPartialHexTube(FemModel3d model,
                                              double l,
                                              double rin,
                                              double rout,
                                              double theta,
                                              int nl,
                                              int nr,
                                              int ntheta)
```
    Creates a partial tube made of hex elements. Identical to createPartialTube(FemModel3d,FemElementType,double,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.Hex.
  - createPartialTetTube
```
public static FemModel3d createPartialTetTube(FemModel3d model,
                                              double l,
                                              double rin,
                                              double rout,
                                              double theta,
                                              int nl,
                                              int nr,
                                              int ntheta)
```
    Creates a partial tube made of tet elements. Identical to createPartialTube(FemModel3d,FemElementType,double,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.Tet.
  - createHexTorus
```
public static FemModel3d createHexTorus(FemModel3d model,
                                        double R,
                                        double rin,
                                        double rout,
                                        int nt,
                                        int nl,
                                        int nr)
```
    Creates a hollow torus made of hex elements. Identical to createTorus(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.Hex.
  - createPartialHexTorus
```
public static FemModel3d createPartialHexTorus(FemModel3d model,
                                               double R,
                                               double rin,
                                               double rout,
                                               int nt,
                                               int nl,
                                               int nr,
                                               double theta)
```
    Creates a hollow partial torus made of hex elements.
    
    Parameters:
    
    model - model to which the elements should be added, or null if the model is to be created from scratch.
    
    R - major radius
    
    rin - inner part of the minor radius
    
    rout - outer part of the minor radius
    
    nt - element resolution around the minor radius
    
    nl - element resolution around the major radius
    
    nr - element resolution (plus 1) along the inner thickness
    
    theta - angular circumference around the major radius. Specifying 2*Math.PI will result in a full torus.
    
    Returns:
    
    created FEM model
  - createPartialTetTorus
```
public static FemModel3d createPartialTetTorus(FemModel3d model,
                                               double R,
                                               double rin,
                                               double rout,
                                               int nt,
                                               int nl,
                                               int nr,
                                               double theta)
```
    Creates a partial torus made of tet elements. Specifying theta as 2*Math.PI will create a full torus.
    
    Parameters:
    
    model - model to which the elements should be added, or null if the model is to be created from scratch.
    
    R - major radius
    
    rin - inner part of the minor radius
    
    rout - outer part of the minor radius
    
    nt - element resolution around the minor radius (will be rounded up to an even number)
    
    nl - element resolution around the major radius (for a full torus, will be rounded up to an even number)
    
    nr - element resolution (plus 1) along the inner thickness
    
    theta - angular circumference around the major radius. Specifying 2*Math.PI will result in a full torus.
    
    Returns:
    
    created FEM model
  - createTetTorus
```
public static FemModel3d createTetTorus(FemModel3d model,
                                        double R,
                                        double rin,
                                        double rout,
                                        int nt,
                                        int nl,
                                        int nr)
```
    Creates a torus made of tet elements.
    
    Parameters:
    
    model - model to which the elements should be added, or null if the model is to be created from scratch.
    
    R - major radius
    
    rin - inner part of the minor radius
    
    rout - outer part of the minor radius
    
    nt - element resolution around the minor radius
    
    nl - element resolution around the major radius
    
    nr - element resolution (plus 1) along the inner thickness
    
    Returns:
    
    created FEM model
  - createQuadraticModel
```
public static FemModel3d createQuadraticModel(FemModel3d quadMod,
                                              FemModel3d linMod)
```
    Takes a FemModel3d containing linear elements, and creates a quadratic model whose elements are the corresponding quadratic elements, with new nodes inserted along the edges as required. The new quadratic model will have straight edges in the rest position.
    
    Parameters:
    
    linMod - A FemModel3d previously inialized with only linear elements.
  - createQuadtetTube
```
public static FemModel3d createQuadtetTube(FemModel3d model,
                                           double l,
                                           double rin,
                                           double rout,
                                           int nt,
                                           int nl,
                                           int nr)
```
    Creates a tube made of quadratic tet elements. Identical to createTube(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.QuadTet.
  - createQuadtetTorus
```
public static FemModel3d createQuadtetTorus(FemModel3d model,
                                            double R,
                                            double rin,
                                            double rout,
                                            int nt,
                                            int nl,
                                            int nr)
```
    Creates a hollow torus made of quadratic tet elements. Identical to createTorus(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.QuadTet.
  - createQuadtetExtrusion
```
public static FemModel3d createQuadtetExtrusion(FemModel3d model,
                                                int n,
                                                double d,
                                                double zOffset,
                                                PolygonalMesh surface)
```
    Creates a shell-based FEM model made of quadratic tet elements by extruding a surface mesh along the normal direction of its faces. Identical to createExtrusion(FemModel3d,FemElementType,int,double,double,PolygonalMesh) with the element type set to FemFactory.FemElementType.QuadTet.
  - createQuadhexTube
```
public static FemModel3d createQuadhexTube(FemModel3d model,
                                           double l,
                                           double rin,
                                           double rout,
                                           int nt,
                                           int nl,
                                           int nr)
```
    Creates a tube made of quadratic hex elements. Identical to createTube(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.QuadHex.
  - createQuadhexTorus
```
public static FemModel3d createQuadhexTorus(FemModel3d model,
                                            double R,
                                            double rin,
                                            double rout,
                                            int nt,
                                            int nl,
                                            int nr)
```
    Creates a hollow torus made of quadratic hex elements. Identical to createTorus(FemModel3d,FemElementType,double,double,double,int,int,int) with the element type set to FemFactory.FemElementType.QuadHex.
  - createQuadhexExtrusion
```
public static FemModel3d createQuadhexExtrusion(FemModel3d model,
                                                int n,
                                                double d,
                                                double zOffset,
                                                PolygonalMesh surface)
```
    Creates a shell-based FEM model made of quadratic hex elements by extruding a surface mesh along the normal direction of its faces. The surface mesh must be composed of quads. Identical to createExtrusion(FemModel3d,FemElementType,int,double,double,PolygonalMesh) with the element type set to FemFactory.FemElementType.QuadHex.
  - createQuadwedgeExtrusion
```
public static FemModel3d createQuadwedgeExtrusion(FemModel3d model,
                                                  int n,
                                                  double d,
                                                  double zOffset,
                                                  PolygonalMesh surface)
```
    Creates a shell-based FEM model made of quadratic wedge elements by extruding a surface mesh along the normal direction of its faces. The surface mesh must be composed of triangles. Identical to createExtrusion(FemModel3d,FemElementType,int,double,double,PolygonalMesh) with the element type set to FemFactory.FemElementType.Wedge.
  - createHexExtrusion
```
public static FemModel3d createHexExtrusion(FemModel3d model,
                                            int n,
                                            double d,
                                            double zOffset,
                                            PolygonalMesh surface)
```
    Creates a shell-based FEM model made of hex elements by extruding a surface mesh along the normal direction of its faces. The surface mesh must be composed of quads. Identical to createExtrusion(FemModel3d,FemElementType,int,double,double,PolygonalMesh) with the element type set to FemFactory.FemElementType.Hex.
  - createWedgeExtrusion
```
public static FemModel3d createWedgeExtrusion(FemModel3d model,
                                              int n,
                                              double d,
                                              double zOffset,
                                              PolygonalMesh surface)
```
    Creates a shell-based FEM model made of wedge elements by extruding a surface mesh along the normal direction of its faces. The surface mesh must be composed of triangles. Identical to createExtrusion(FemModel3d,FemElementType,int,double,double,PolygonalMesh) with the element type set to FemFactory.FemElementType.Wedge.
  - createHexWedgeExtrusion
```
public static FemModel3d createHexWedgeExtrusion(FemModel3d model,
                                                 int n,
                                                 double d,
                                                 double zOffset,
                                                 PolygonalMesh surface,
                                                 FemModel3d surfaceFem)
```
    Creates a shell-based FEM model by extruding a surface mesh along the normal direction of its faces. The element types used depend on the underlying faces: triangular faces generate wedge elements, while quad faces generate hex elements. If the mesh is the surface mesh of an underlying FemModel, then each triangle is examined to see if it is associated with an underlying hex element, and if it is, then a hex element is extruded from both the surface triangles connected to that element. The shell can have multiple layers; the number of layers is n.
    
    Parameters:
    
    model - model to which the elements should be added, or null if the model is to be created from scratch. Note that model must be different from surfaceFem
    
    n - number of layers
    
    d - layer thickness
    
    zOffset - offset from the surface
    
    surface - surface mesh to extrude
    
    surfaceFem - FEM associated with the surface mesh, or null if there is no associated FEM.
    
    Returns:
    
    extruded FEM model, which will be model if that argument is not null.
  - createExtrusion
```
public static FemModel3d createExtrusion(FemModel3d model,
                                         int n,
                                         double d,
                                         double zOffset,
                                         PolygonalMesh surface)
```
    Creates a shell-type FEM model by extruding a surface mesh along the normal direction of its faces. The element types used depend on the underlying faces: triangular faces generate wedge elements, while quad faces generate hex elements. The shell can have multiple layers; the number of layers is n.
    
    Parameters:
    
    model - model to which the elements should be added, or null if the model is to be created from scratch.
    
    n - number of layers
    
    d - layer thickness
    
    zOffset - offset from the surface
    
    surface - surface mesh to extrude
    
    Returns:
    
    extruded FEM model, which will be model if that argument is not null
    
    Throws:
    
    java.lang.IllegalArgumentException - if the specified element type is not supported, or if the surface faces are not triangles or quads.
  - createExtrusion
```
public static FemModel3d createExtrusion(FemModel3d model,
                                         int n,
                                         double d,
                                         double zOffset,
                                         FemModel3d shellFem)
```
    Creates a shell-type FEM model by extruding the shell elements of an existing surface mesh along the direction of the associated vertex normals. The element types used depend on the underlying shell elements: triangular elements generate wedge elements, while quad elements generate hex elements. The shell can have multiple layers; the number of layers is n.
    
    Parameters:
    
    model - model to which the elements should be added, or null if the model is to be created from scratch.
    
    n - number of layers
    
    d - layer thickness
    
    zOffset - offset from the surface
    
    shellFem - FEM model suppling the shell elements
    
    Returns:
    
    extruded FEM model, which will be model if that argument is not null
    
    Throws:
    
    java.lang.IllegalArgumentException - if the specified element type is not supported, or if the surface faces are not triangles or quads.
  - createTetExtrusion
```
public static FemModel3d createTetExtrusion(FemModel3d model,
                                            int n,
                                            double d,
                                            double zOffset,
                                            PolygonalMesh surface)
```
    Creates a shell-based FEM model made of tet elements by extruding a surface mesh along the normal direction of its faces. Identical to createExtrusion(FemModel3d,FemElementType,int,double,double,PolygonalMesh) with the element type set to FemFactory.FemElementType.Tet.
  - createTube
```
public static FemModel3d createTube(FemModel3d model,
                                    FemFactory.FemElementType type,
                                    double l,
                                    double rin,
                                    double rout,
                                    int nt,
                                    int nl,
                                    int nr)
```
    Creates a tube made of either tet, hex, quadTet, or quadHex elements, as specified by type. Note that the element resolution nt around the central axis will be rounded up to an even number for tet or quadTet models.
    
    Parameters:
    
    model - model to which the elements should be added, or null if the model is to be created from scratch.
    
    type - desired element type
    
    l - length along the z axis
    
    rin - inner radius
    
    rout - outer radius
    
    nt - element resolution around the central axis (will be rounded up to an even number for tet or quadTet models)
    
    nl - element resolution along the length
    
    nr - element resolution along the thickness
    
    Returns:
    
    created FEM model
    
    Throws:
    
    java.lang.IllegalArgumentException - if the specified element type is not supported
  - createPartialTube
```
public static FemModel3d createPartialTube(FemModel3d model,
                                           FemFactory.FemElementType type,
                                           double l,
                                           double rin,
                                           double rout,
                                           double theta,
                                           int nl,
                                           int nr,
                                           int ntheta)
```
    Creates a partial tube made of either tet or hex elements, as specified by type.
    
    Parameters:
    
    model - model to which the elements should be added, or null if the model is to be created from scratch.
    
    type - desired element type
    
    l - length along the z axis
    
    rin - inner radius
    
    rout - outer radius
    
    theta - size of the partial tube slice, in radians
    
    nl - element resolution along the length
    
    nr - element resolution along the thickness
    
    ntheta - element resolution along the slice
    
    Returns:
    
    created FEM model
    
    Throws:
    
    java.lang.IllegalArgumentException - if the specified element type is not supported
  - createTorus
```
public static FemModel3d createTorus(FemModel3d model,
                                     FemFactory.FemElementType type,
                                     double R,
                                     double rin,
                                     double rout,
                                     int nt,
                                     int nl,
                                     int nr)
```
    Creates a hollow torus made of either tet, hex, quadTet, or quadHex elements, as specified by type. The result is essentially a tube, with inner and outer radii given by rin and rout, bent around the major radius R and connected. For tet or quadTet models, the element resolutions nt and nl will be rounded up to an even number.
    
    Parameters:
    
    model - model to which the elements should be added, or null if the model is to be created from scratch.
    
    type - desired element type
    
    R - major radius
    
    rin - inner part of the minor radius
    
    rout - outer part of the minor radius
    
    nt - element resolution around the major radius (will be rounded up to an even number for tet or quadTet models)
    
    nl - element resolution around the minor radius (will be rounded up to an even number for tet or quadTet models)
    
    nr - element resolution along the inner thickness
    
    Returns:
    
    created FEM model
    
    Throws:
    
    java.lang.IllegalArgumentException - if the specified element type is not supported
  - createExtrusion
```
public static FemModel3d createExtrusion(FemModel3d model,
                                         FemFactory.FemElementType type,
                                         int n,
                                         double d,
                                         double zOffset,
                                         PolygonalMesh surface)
```
    Creates a shell-based FEM model by extruding a surface mesh along the normal direction of its faces. The model is composed of either tet, hex, quadTet or quadHex elements, as specified by type. The shell can have multiple layers; the number of layers is n.
    
    Parameters:
    
    model - model to which the elements should be added, or null if the model is to be created from scratch.
    
    type - desired element type
    
    n - number of layers
    
    d - layer thickness
    
    zOffset - offset from the surface
    
    surface - surface mesh to extrude
    
    Returns:
    
    extruded FEM model, which will be model if that argument is not null
    
    Throws:
    
    java.lang.IllegalArgumentException - if the specified element type is not supported, or if the surface faces are incompatible with the element type.
  - createFromMesh
```
public static FemModel3d createFromMesh(FemModel3d model,
                                        PolygonalMesh surface,
                                        double quality)
```
    Creates a tetrahedral FEM model from a triangular surface mesh. The tetrahedra will be added to either an existing model (supplied through the argument model), or a newly created FemModel3d (if model is null).
    The tessellation is done using tetgen, which is called through a JNI interface. The tessellation quality is controlled using the quality variable, described below.
    
    Parameters:
    
    model - model to which the tetrahedra should be added, or null if the model is to be created from scratch.
    
    surface - triangular surface mesh used to define the tessellation.
    
    quality - If 0, then only the mesh nodes will be used to form the tessellation. However, this may result in highly degenerate tetrahedra. Otherwise, if > 0, tetgen will add additional nodes to ensure that the minimum edge-radius ratio does not exceed quality. A good default value for quality is 2. If set too small (such as less then 1), then tetgen may not terminate.
    
    Returns:
    
    the FEM model
  - createFromMeshAndPoints
```
public static FemModel3d createFromMeshAndPoints(FemModel3d model,
                                                 PolygonalMesh surface,
                                                 double quality,
                                                 Point3d[] pnts)
```
    Constrained Delaunay, including the supplied list of points if they fall inside the surface
  - refineFem
```
public static FemModel3d refineFem(FemModel3d model,
                                   FemModel3d input,
                                   double quality,
                                   Point3d[] pnts)
```
    Creates a refined version of a an existing tetrahedral FEM model using tetgen and a list of supplemental node locations.
    
    Parameters:
    
    model - model in which the refined model be built, or null if the model is to be created from scratch.
    
    input - original FEM model which is to be refined
    
    quality - quality factor used by tetgen to refine the model
    
    pnts - locations of the supplemental node
    
    Returns:
    
    refined FEM model
  - refineFem
```
public static FemModel3d refineFem(FemModel3d model,
                                   FemModel3d input,
                                   double quality)
```
    Creates a refined version of a an existing tetrahedral FEM model using tetgen.
    
    Parameters:
    
    model - model in which the refined model be built, or null if the model is to be created from scratch.
    
    input - original FEM model which is to be refined
    
    quality - quality factor used by tetgen to refine the model
    
    Returns:
    
    refined FEM model
  - addFem
```
public static void addFem(FemModel3d fem0,
                          FemModel3d fem1)
```
    Adds a copy of the nodes, elements, markers and attachments from fem1 to fem0. Nodes in fem1 are merged with nodes in fem0 that are within TOL distance of each other, where TOL is 1e-8 times the maximum radius of fem0 and fem1. For precise control of node merging, use addFem(FemModel3d,FemModel3d,double).
    
    Parameters:
    
    fem0 - FEM model to which components should be added
    
    fem1 - FEM model providing components
  - addFem
```
public static void addFem(FemModel3d fem0,
                          FemModel3d fem1,
                          double nodeMergeDist)
```
    Adds a copy of the nodes, elements, markers and attachments from fem1 to fem0.
    
    Parameters:
    
    fem0 - FEM model to which components should be added
    
    fem1 - FEM model providing components
    
    nodeMergeDist - If >= 0, causes nearby nodes of fem1 and fem0 to be merged: any node of fem1 that is within nodeMergeDist of a node in fem0 is replaced by the nearest node in fem0.
  - subdivideFem
```
public static FemModel3d subdivideFem(FemModel3d femr,
                                      FemModel3d fem0)
```
    Creates a subdvided FEM model by subdividing all the elements of an existing model into eight sub-elements, adding additional nodes as required. The existing model is not modified. At present, this is supported only for models composed of tetrahedra, hexahedra, and wedges. Markers in the original mesh are copied, but attachments (T-junction connections) are not. Likewise, if the original FEM is a FemMuscleModel, the muscle group information is not copied either.
    
    Parameters:
    
    femr - model in which refined FEM is to be constructed, or null if the model is to be created from scratch.
    
    fem0 - existing FEM model to be refined.
  - subdivideFem
```
public static FemModel3d subdivideFem(FemModel3d femr,
                                      FemModel3d fem0,
                                      boolean addMarkers)
```
  - createFromElementList
```
public static void createFromElementList(FemModel3d out,
                                         java.util.Collection<FemElement3d> elemList)
```
    Creates a new model by duplicating nodes and elements
    
    Parameters:
    
    out - model to fill
    
    elemList - elements to build model from
  - setPlanarNodesFixed
```
public static void setPlanarNodesFixed(FemModel fem,
                                       Point3d center,
                                       Vector3d normal,
                                       boolean fixed)
```

Class FemFactory

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FemFactory

Method Detail

createTetGrid

createPyramidGrid

createHexGrid

createWedgeGrid

createQuadtetGrid

createQuadhexGrid

createQuadwedgeGrid

createQuadpyramidGrid

createGrid

createShellTriGrid

createShellModel

createShellQuadGrid

createShellGrid

mergeCollapsedNodes

createIcosahedralSphere

createPolarSphere

createSphere

createTetSphere

createQuadtetSphere

createConformalHexSphere

createHexSphere

createFlattenedHexSphere

createEllipsoid

createTetEllipsoid

createConformalHexEllipsoid

createHexEllipsoid

createTetEllipsoid

createCylinder

createRoundedHexWedgeDisc

createRoundedDisc

createHexWedgeCylinder

createTetCylinder

createQuadtetCylinder

createWedgeCylinder

createTetCylinder

createQuadtetCylinder

conformalMapEllipseRectangle

conformalMapRectangleEllipse

bilipschitzMapSphereCylinder

bilipschitzMapCylinderSphere

mapCubeToSphere

mapSphereToCube

createConformalHexCylinder

createHexCylinder

createPartialCylinder

createPartialHexWedgeCylinder

createHexTube

createTetTube

createPartialHexTube

createPartialTetTube

createHexTorus

createPartialHexTorus

createPartialTetTorus

createTetTorus

createQuadraticModel

createQuadtetTube

createQuadtetTorus

createQuadtetExtrusion

createQuadhexTube

createQuadhexTorus

createQuadhexExtrusion

createQuadwedgeExtrusion

createHexExtrusion

createWedgeExtrusion

createHexWedgeExtrusion

createExtrusion

createExtrusion

createTetExtrusion

createTube

createPartialTube

createTorus

createExtrusion