FemElement3dBase (Artisynth API documentation)

java.lang.Object
- artisynth.core.modelbase.ModelComponentBase
- - artisynth.core.modelbase.RenderableComponentBase
  - - artisynth.core.femmodels.FemElement
    - - artisynth.core.femmodels.FemElement3dBase

All Implemented Interfaces:

FrameAttachable, PointAttachable, CopyableComponent, HasNumericState, ModelComponent, PostScannable, PropertyChangeListener, RenderableComponent, ScalableUnits, java.lang.Cloneable, Boundable, HasProperties, HierarchyNode, HasRenderProps, IsRenderable, IsSelectable, Renderable, Scannable

Direct Known Subclasses:

FemElement3d, ShellElement3d
```
public abstract class FemElement3dBase
extends FemElement
implements PointAttachable, FrameAttachable
```

Nested Class Summary
- Nested classes/interfaces inherited from class artisynth.core.femmodels.FemElement
  FemElement.ElementClass
- Nested classes/interfaces inherited from interface artisynth.core.modelbase.ModelComponent
  ModelComponent.NavpanelVisibility

Field Summary

Fields
Modifier and Type Field and Description

static PropertyList myProps
- Fields inherited from class artisynth.core.femmodels.FemElement
  setScannedNodesInPostscan, writeNodeRefsByNumber
- Fields inherited from class artisynth.core.modelbase.ModelComponentBase
  enforceUniqueCompositeNames, enforceUniqueNames, myNumber, NULL_OBJ, useCompactPathNames
- Fields inherited from interface artisynth.core.modelbase.CopyableComponent
  COPY_REFERENCES, REST_POSITION
- Fields inherited from interface maspack.render.IsRenderable
  TRANSPARENT, TWO_DIMENSIONAL

Fields
Modifier and Type	Field and Description
`static PropertyList`	`myProps`

Constructor Summary

Constructors
Constructor and Description

FemElement3dBase()

Constructors
Constructor and Description
`FemElement3dBase()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addConsistentGravity(Vector3d gacc)`
`void`	`addConsistentMass(SparseNumberedBlockMatrix M)`
`void`	`advanceState(double t0, double t1)` If `HasNumericState.requiresAdvance()` and `HasNumericState.hasState()` both return `true`, then this method is called each time step by the system integrator to update this component's state.
`void`	`clearRotationData()` Should be called only if we want to liberate rotation data memory for some reason.
`MatrixNd`	`computeConsistentMass()`
`double`	`computeCovariance(Matrix3d C)` Computes the covariance of the element, assuming a uniform density of one.
`double`	`computeDirectedRenderSize(Vector3d dir)` Compute size of an element's render coordinates along a specified direction.
`VectorNd`	`computeGravityWeights()`
`abstract void`	`computeJacobian(Matrix3d J, Vector3d ncoords)`
`abstract void`	`computeLocalPosition(Vector3d pnt, Vector3d ncoords)` Compute position within element based on natural coordinates
`void`	`computeRenderCoordsAndGradient(Matrix3d F, float[] coords)` Computes the current coordinates and deformation gradient at the warping point, using render coordinates.
`void`	`connectToHierarchy(CompositeComponent hcomp)` Called by the system after this component, or an ancestor of this component, is added to the component hierarchy (i.e., added as a child of another CompositeComponent).
`boolean`	`containsEdge(FemNode3d n0, FemNode3d n1)`
`boolean`	`containsFace(FemNode3d n0, FemNode3d n1, FemNode3d n2)`
`boolean`	`containsFace(FemNode3d n0, FemNode3d n1, FemNode3d n2, FemNode3d n3)`
`boolean`	`containsNode(FemNode3d n)`
`abstract boolean`	`coordsAreInside(Vector3d ncoords)` Queries whether or not a set of natural coordinates are inside this element.
`FemElement3dBase`	`copy(int flags, java.util.Map<ModelComponent,ModelComponent> copyMap)` Create a copy of this component.
`FrameFem3dAttachment`	`createFrameAttachment(Frame frame, RigidTransform3d TFW)` Returns a FrameAttachment that attaches a `frame` to this component.
`static IntegrationPoint3d[]`	`createIntegrationPoints(FemElement3dBase sampleElem, double[] ncoords)` Create a set of integration points for a given element, using a specified set of natural coordinates.
`PointAttachment`	`createPointAttachment(Point pnt)` Returns a PointAttachment that attaches `pnt` to this component.
`void`	`disconnectFromHierarchy(CompositeComponent hcomp)` Called by the system after this component, or an ancestor of this component, is removed from the component hierarchy (i.e., removed as a child of its parent).
`IntegrationPoint3d[]`	`getAllIntegrationPoints()` Returns all integration points actually used by this element, including the warping point (see `getWarpingPoint()`).
`PropertyList`	`getAllPropertyInfo()` Returns a list giving static information about all properties exported by this object.
`boolean`	`getCopyReferences(java.util.List<ModelComponent> refs, ModelComponent ancestor)` Collects external references which must also be copied in order to duplicate this component.
`Matrix3d`	`getDeformation()` Returns the deformation matrix H of this element, computing it if necessary.
`Matrix3d`	`getDeformation(PolarDecomposition3d polard)` Returns the deformation matrix H of this element, computing it if necessary.
`abstract void`	`getdNds(Vector3d dNds, int i, Vector3d coords)`
`abstract int[]`	`getEdgeIndices()`
`FemElement.ElementClass`	`getElementClass()`
`double`	`getElementWidgetSize()`
`PropertyMode`	`getElementWidgetSizeMode()`
`abstract int[]`	`getFaceIndices()`
`FaceNodes3d[]`	`getFaces()` Returns an array of FaceNodes3d describing a set of faces associated with this element.
`FemModel3d`	`getFemModel()`
`Matrix3d`	`getFrame()`
`abstract double[]`	`getIntegrationCoords()` Returns the natural coordinates and weights for the default integration points associated with this element.
`IntegrationData3d[]`	`getIntegrationData()`
`abstract IntegrationPoint3d[]`	`getIntegrationPoints()` Returns the integration points associated with this element, not including the warping point (see `getWarpingPoint()`).
`MatrixNd`	`getIntegrationShapeMatrix()` Creates and returns a shape matrix for integration points of this element.
`Matrix3d`	`getInvB()` Returns the inverse B matrix of this element, computing it if necessary.
`Matrix3d`	`getInvB(PolarDecomposition3d polard)` Returns the inverse B matrix of this element, computing it if necessary.
`boolean`	`getMarkerCoordinates(VectorNd coords, Vector3d ncoords, Point3d pnt, boolean checkInside)`
`abstract double`	`getN(int i, Vector3d coords)`
`boolean`	`getNaturalCoordinates(Vector3d coords, Point3d pnt)` Calls `getNaturalCoordinates(Vector3d,Point3d,int)` with a default maximum number of iterations.
`int`	`getNaturalCoordinates(Vector3d coords, Point3d pnt, int maxIters)` Given point p, get its natural coordinates with respect to this element.
`int`	`getNaturalCoordinatesGSS(Vector3d coords, Point3d pnt, int maxIters)` Given point p, get its natural coordinates with respect to this element.
`MatrixNd`	`getNodalAveragingMatrix()` Returns the nodal averaging matrix for this element, used for extrapolating values from the integration points to the element nodes for purposes of computing average nodal values.
`abstract MatrixNd`	`getNodalExtrapolationMatrix()` Returns the nodal extrapolation matrix for this element.
`abstract double[]`	`getNodeCoords()`
`void`	`getNodeCoords(Vector3d coords, int nodeIdx)`
`abstract double[]`	`getNodeMassWeights()`
`FemNodeNeighbor[][]`	`getNodeNeighbors()`
`FemNode3d[]`	`getNodes()`
`int`	`getNumFaces()`
`RotationMatrix3d`	`getRotation()` Returns the rotation of this element, computing it if necessary.
`RotationMatrix3d`	`getRotation(PolarDecomposition3d polard)` Returns the rotation of this element, computing it if necessary.
`void`	`getState(DataBuffer data)` Saves state information for this component by adding data to the supplied DataBuffer.
`StiffnessWarper3d`	`getStiffnessWarper(double weight)` Retrieves the current stiffness warper.
`abstract int[]`	`getTriangulatedFaceIndices()`
`IntegrationData3d`	`getWarpingData()`
`abstract IntegrationPoint3d`	`getWarpingPoint()` Returns the special warping integration point which is located at the center of the element and is used for computing stiffness warping and other specialized applications.
`void`	`invalidateRestData()` Invalidate data that relies on the element's rest position, such as rest Jacobians and the base stiffness for co-rotated stiffness.
`void`	`invalidateRotationData()` Should be after node positions change and before subsequent calls to `getRotation()`, `getDeformation()`, or `getInvB()`.
`boolean`	`isInside(Point3d pnt)` Tests whether or not a point is inside an element.
`boolean`	`isInvertedAtRest()` Returns true if the rest position for this element results in a negative Jacobian determinant for at least one integration point.
`void`	`notifyStateVersionChanged()`
`int`	`numAllIntegrationPoints()` Returns the number of integration points actually used by this element, including the warping point.
`abstract int`	`numIntegrationPoints()` Returns the number of integration points actually used by this element (not including the warping point, if any).
`abstract void`	`renderWidget(Renderer renderer, double size, RenderProps props)`
`boolean`	`requiresAdvance()` Returns `true` if the state of this component must be updated each time step using `HasNumericState.advanceState(double, double)`.
`void`	`setElementWidgetSize(double size)`
`void`	`setElementWidgetSizeMode(PropertyMode mode)`
`void`	`setFrame(Matrix3dBase M)` Set reference frame information for this element.
`void`	`setNodes(FemNode3d[] nodes)`
`void`	`setState(DataBuffer data)` Restores the state for this component by reading from the supplied data buffer, starting at the current buffer offsets.
`void`	`setStiffnessWarper(StiffnessWarper3d warper)` Explicitly sets a stiffness warper
`FemNode3d[][]`	`triangulateFace(FaceNodes3d face)`

Methods inherited from class artisynth.core.femmodels.FemElement
addAugmentingMaterial, addAuxiliaryMaterial, computeCentroid, computeRestVolumes, computeVolumes, containsNode, createRenderProps, defaultRenderPropsAreNull, getAugmentingMaterials, getAuxiliaryMaterials, getDensity, getDensityMode, getEffectiveMaterial, getHardReferences, getIndex, getLocalNodeIndex, getMass, getMaterial, getPlasticDeformation, getPoint, getRestVolume, getSelection, getStateVersion, getStrainEnergy, getVolume, hasActiveNodes, hasControllableNodes, hasState, integrationPointsInterpolateToNodes, integrationPointsMapToNodes, invalidateMassIfNecessary, isDuplicatable, isInverted, isLinear, isMassExplicit, materialsAreInvertible, numAugmentingMaterials, numAuxiliaryMaterials, numberString, numNodes, numPoints, prerender, propertyChanged, removeAugmentingMaterial, removeAuxiliaryMaterial, render, render, scaleDistance, scaleMass, setDensity, setDensityMode, setExplicitMass, setIndex, setInverted, setMass, setMaterial, setPlasticDeformation, unsetExplicitMass, updateBounds, updateRestVolumeAndMass

Methods inherited from class artisynth.core.modelbase.RenderableComponentBase
getRenderHints, getRenderProps, isSelectable, isVisible, numSelectionQueriesNeeded, setRenderProps, setVisible, updateRenderProps

Methods inherited from class artisynth.core.modelbase.ModelComponentBase
checkFlag, checkName, checkNameUniqueness, clearFlag, clone, createTempFlag, getChildren, getGrandParent, getName, getNameRange, getNavpanelVisibility, getNavpanelVisibility, getNumber, getParent, getProperty, getSoftReferences, hasChildren, isFixed, isMarked, isScanning, isSelected, isWritable, makeValidName, makeValidName, notifyParentOfChange, postscan, printReferences, recursivelyContained, recursivelyContains, removeTempFlag, scan, setFixed, setFlag, setMarked, setName, setNavpanelVisibility, setNavpanelVisibility, setNumber, setParent, setScanning, setSelected, setWritable, updateReferences, write

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

Methods inherited from interface artisynth.core.modelbase.ModelComponent
getHardReferences, getName, getNavpanelVisibility, getNumber, getParent, getSoftReferences, hasState, isFixed, isMarked, isSelected, notifyParentOfChange, scan, setFixed, setMarked, setName, setNumber, setParent, setSelected, setWritable, updateReferences

Methods inherited from interface maspack.properties.HasProperties
getProperty

Methods inherited from interface maspack.properties.HierarchyNode
getChildren, hasChildren

Methods inherited from interface artisynth.core.modelbase.PostScannable
postscan

Methods inherited from interface maspack.util.Scannable
isWritable, write

Methods inherited from interface artisynth.core.modelbase.HasNumericState
getAuxVarDerivative, getAuxVarState, numAuxVars, setAuxVarState

- Field Detail
  - myProps
```
public static PropertyList myProps
```
- Constructor Detail
  - FemElement3dBase
```
public FemElement3dBase()
```
- Method Detail
  - getAllPropertyInfo
```
public PropertyList getAllPropertyInfo()
```
    Description copied from interface: HasProperties
    
    Returns a list giving static information about all properties exported by this object.
    
    Specified by:
    
    getAllPropertyInfo in interface HasProperties
    
    Overrides:
    
    getAllPropertyInfo in class FemElement
    
    Returns:
    
    static information for all exported properties
  - getElementClass
```
public FemElement.ElementClass getElementClass()
```
    Specified by:
    
    getElementClass in class FemElement
  - setElementWidgetSize
```
public void setElementWidgetSize(double size)
```
  - getElementWidgetSize
```
public double getElementWidgetSize()
```
  - setElementWidgetSizeMode
```
public void setElementWidgetSizeMode(PropertyMode mode)
```
  - getElementWidgetSizeMode
```
public PropertyMode getElementWidgetSizeMode()
```
  - getFemModel
```
public FemModel3d getFemModel()
```
    Overrides:
    
    getFemModel in class FemElement
  - getNodeCoords
```
public abstract double[] getNodeCoords()
```
  - getNodeMassWeights
```
public abstract double[] getNodeMassWeights()
```
  - getNodeCoords
```
public void getNodeCoords(Vector3d coords,
                          int nodeIdx)
```
  - getNodes
```
public FemNode3d[] getNodes()
```
    Specified by:
    
    getNodes in class FemElement
  - setNodes
```
public void setNodes(FemNode3d[] nodes)
```
  - getNodeNeighbors
```
public FemNodeNeighbor[][] getNodeNeighbors()
```
  - containsNode
```
public boolean containsNode(FemNode3d n)
```
  - getIntegrationCoords
```
public abstract double[] getIntegrationCoords()
```
    Returns the natural coordinates and weights for the default integration points associated with this element. The information is returned as an array of length 4*num, where num is the number of coordinates, and the information for each coordinate consists of a 4-tuple giving the three natural coordinates followed by the weight.
    
    Returns:
    
    coordinates and weights for the default integration points.
  - numIntegrationPoints
```
public abstract int numIntegrationPoints()
```
    Returns the number of integration points actually used by this element (not including the warping point, if any). Typically this number will equal the length of the integration point array returned by getIntegrationPoints(), but in some cases (such as shell elements being used as membrane elements), it will be less.
    
    Returns:
    
    number of integration points used by this element
  - getIntegrationPoints
```
public abstract IntegrationPoint3d[] getIntegrationPoints()
```
    Returns the integration points associated with this element, not including the warping point (see getWarpingPoint()). In some cases, such as with membrane elements, only the first n points of these points are actaully used, where n is the number returned by numIntegrationPoints().
  - numAllIntegrationPoints
```
public int numAllIntegrationPoints()
```
    Returns the number of integration points actually used by this element, including the warping point. Usually, this is 1+n, where n is the number returned by numIntegrationPoints(). In cases where n = 1, the (one) integration point is also the warping point, and so this method returns 1.
    
    Returns:
    
    number of all integration points used by this element
  - getAllIntegrationPoints
```
public IntegrationPoint3d[] getAllIntegrationPoints()
```
    Returns all integration points actually used by this element, including the warping point (see getWarpingPoint()). The number of points equals numAllIntegrationPoints(). The first n points correspond to the first n points returned by getIntegrationPoints(), where n is the number returned by numIntegrationPoints(), and the last point is the warping point. In cases where n = 1, there is only one integration point which is also the warping point.
  - createIntegrationPoints
```
public static IntegrationPoint3d[] createIntegrationPoints(FemElement3dBase sampleElem,
                                                           double[] ncoords)
```
    Create a set of integration points for a given element, using a specified set of natural coordinates.
    
    Parameters:
    
    sampleElem - representative element
    
    ncoords - location of the integration points in natural coordinates
    
    Returns:
    
    created integration points
  - getIntegrationData
```
public IntegrationData3d[] getIntegrationData()
```
  - invalidateRestData
```
public void invalidateRestData()
```
    Description copied from class: FemElement
    
    Invalidate data that relies on the element's rest position, such as rest Jacobians and the base stiffness for co-rotated stiffness.
    
    Overrides:
    
    invalidateRestData in class FemElement
  - getRotation
```
public RotationMatrix3d getRotation()
```
    Returns the rotation of this element, computing it if necessary. The rotation R is computed from the deformation gradient F at the element's warping point, using the modified polar decomposition
```
 F = R H
 
```
    Here H is the deformation matrix, which is symmetric but not necessarily positive definite, in order to ensure that R is right-handed.
    Returns:
    
    element rotation matrix
  - getRotation
```
public RotationMatrix3d getRotation(PolarDecomposition3d polard)
```
    Returns the rotation of this element, computing it if necessary. See getRotation() for more details.
    
    Parameters:
    
    polard - if non-null, supplies a PolarDecomposition3d to be used if needed for computing the polar decomposition
    
    Returns:
    
    element rotation matrix
  - getDeformation
```
public Matrix3d getDeformation()
```
    Returns the deformation matrix H of this element, computing it if necessary. See getRotation() for more details.
    
    Returns:
    
    element deformation matrix
  - getDeformation
```
public Matrix3d getDeformation(PolarDecomposition3d polard)
```
    Returns the deformation matrix H of this element, computing it if necessary. See getRotation() for more details.
    
    Parameters:
    
    polard - if non-null, supplies a PolarDecomposition3d to be used if needed for computing the polar decomposition
    
    Returns:
    
    element deformation matrix
  - getInvB
```
public Matrix3d getInvB()
```
    Returns the inverse B matrix of this element, computing it if necessary. The inverse B matrix is computed from the deformation matrix H using the formula
```
 inv(B) = inv (trace(H) - H)
 
```
    and is used in computing derivatives of quantities that depend on the rotation matrix R. See getRotation() for details about R and H.
    Returns:
    
    element inverse B matrix
  - getInvB
```
public Matrix3d getInvB(PolarDecomposition3d polard)
```
    Returns the inverse B matrix of this element, computing it if necessary. See getInvB() for details.
    
    Parameters:
    
    polard - if non-null, supplies a PolarDecomposition3d to be used if needed for computing the polar decomposition
    
    Returns:
    
    element inverse B matrix
  - invalidateRotationData
```
public void invalidateRotationData()
```
    Should be after node positions change and before subsequent calls to getRotation(), getDeformation(), or getInvB().
  - clearRotationData
```
public void clearRotationData()
```
    Should be called only if we want to liberate rotation data memory for some reason.
  - getWarpingPoint
```
public abstract IntegrationPoint3d getWarpingPoint()
```
    Returns the special warping integration point which is located at the center of the element and is used for computing stiffness warping and other specialized applications.
  - getWarpingData
```
public IntegrationData3d getWarpingData()
```
  - setStiffnessWarper
```
public void setStiffnessWarper(StiffnessWarper3d warper)
```
    Explicitly sets a stiffness warper
    
    Parameters:
    
    warper - new stiffness warper to use
  - getStiffnessWarper
```
public StiffnessWarper3d getStiffnessWarper(double weight)
```
    Retrieves the current stiffness warper. The warper's cached rest stiffness is updated if necessary
    
    Parameters:
    
    weight - meta weighting to be applied to integration points when updating the rest stiffness. Default value should be 1.0.
    
    Returns:
    
    stiffness warper
  - coordsAreInside
```
public abstract boolean coordsAreInside(Vector3d ncoords)
```
    Queries whether or not a set of natural coordinates are inside this element.
    
    Returns:
    
    true if ncoords are inside this element.
  - isInside
```
public boolean isInside(Point3d pnt)
```
    Tests whether or not a point is inside an element.
    
    Parameters:
    
    pnt - point to check if is inside
    
    Returns:
    
    true if point is inside the element
  - getMarkerCoordinates
```
public boolean getMarkerCoordinates(VectorNd coords,
                                    Vector3d ncoords,
                                    Point3d pnt,
                                    boolean checkInside)
```
    Overrides:
    
    getMarkerCoordinates in class FemElement
  - getNaturalCoordinates
```
public boolean getNaturalCoordinates(Vector3d coords,
                                     Point3d pnt)
```
    Calls getNaturalCoordinates(Vector3d,Point3d,int) with a default maximum number of iterations.
    
    Parameters:
    
    coords - Outputs the natural coordinates, and supplies (on input) an initial guess as to their position.
    
    pnt - A given point (in world coords)
    
    Returns:
    
    true if the calculation converged
  - getNaturalCoordinates
```
public int getNaturalCoordinates(Vector3d coords,
                                 Point3d pnt,
                                 int maxIters)
```
    Given point p, get its natural coordinates with respect to this element. Returns a positive number if the algorithm converges, or -1 if a maximum number of iterations has been reached. Uses a modified Newton's method to solve the equations. The coords argument that returned the coordinates is used, on input, to supply an initial guess of the coordinates. Zero is generally a safe guess.
    
    Parameters:
    
    coords - Outputs the natural coordinates, and supplies (on input) an initial guess as to their position.
    
    pnt - A given point (in world coords)
    
    maxIters - Maximum number of Newton iterations
    
    Returns:
    
    the number of iterations required for convergence, or -1 if the calculation did not converge.
  - getNaturalCoordinatesGSS
```
public int getNaturalCoordinatesGSS(Vector3d coords,
                                    Point3d pnt,
                                    int maxIters)
```
    Given point p, get its natural coordinates with respect to this element. Returns a positive number if the algorithm converges, or -1 if a maximum number of iterations has been reached. Uses a modified Newton's method to solve the equations. The coords argument that returned the coordinates is used, on input, to supply an initial guess of the coordinates. Zero is generally a safe guess.
    
    Parameters:
    
    coords - Outputs the natural coordinates, and supplies (on input) an initial guess as to their position.
    
    pnt - A given point (in world coords)
    
    maxIters - Maximum number of Newton iterations
    
    Returns:
    
    the number of iterations required for convergence, or -1 if the calculation did not converge.
  - getNodalAveragingMatrix
```
public MatrixNd getNodalAveragingMatrix()
```
    Returns the nodal averaging matrix for this element, used for extrapolating values from the integration points to the element nodes for purposes of computing average nodal values. By default, this matrix is the same as that returned by getNodalExtrapolationMatrix(). However, since the purpose of this matrix is for computing nodal averages, simpler matrices can sometimes be used, such as an identity or permutation matrix that assigns the value at each node to that of a specific integration point. Element subclasses may override this method to supply such simplified matrices.
    
    Returns:
    
    nodal extrapolation matrix
  - getNodalExtrapolationMatrix
```
public abstract MatrixNd getNodalExtrapolationMatrix()
```
    Returns the nodal extrapolation matrix for this element. This is a matrix that maps values from the integration points to the element nodes, and is the inverse (or pseudo-inverse) of the integration point shape matrix returned by getIntegrationShapeMatrix().
    
    Returns:
    
    nodal extrapolation matrix
  - getIntegrationShapeMatrix
```
public MatrixNd getIntegrationShapeMatrix()
```
    Creates and returns a shape matrix for integration points of this element. This is an p X n matrix, where p is the number of integration points and n is the number of nodes. Each row gives the current nodal shape function values for a particular integration point.
    The shape matrix maps data from the nodes to the integration points, and so has inverse functionality to the matrix returned by getNodalExtrapolationMatrix().
    
    Returns:
    
    integration point shape matrix for this element.
  - getEdgeIndices
```
public abstract int[] getEdgeIndices()
```
  - getFaceIndices
```
public abstract int[] getFaceIndices()
```
  - getTriangulatedFaceIndices
```
public abstract int[] getTriangulatedFaceIndices()
```
  - triangulateFace
```
public FemNode3d[][] triangulateFace(FaceNodes3d face)
```
  - containsEdge
```
public boolean containsEdge(FemNode3d n0,
                            FemNode3d n1)
```
  - containsFace
```
public boolean containsFace(FemNode3d n0,
                            FemNode3d n1,
                            FemNode3d n2)
```
  - containsFace
```
public boolean containsFace(FemNode3d n0,
                            FemNode3d n1,
                            FemNode3d n2,
                            FemNode3d n3)
```
  - getFaces
```
public FaceNodes3d[] getFaces()
```
    Returns an array of FaceNodes3d describing a set of faces associated with this element. If adjoining elements have matching faces, then the elimination of repeated faces can be used to generate an external mesh for the FEM. If the returned list has zero length, then this method is not supported for the element in question.
    
    Returns:
    
    list of faces for this element
  - getNumFaces
```
public int getNumFaces()
```
  - getN
```
public abstract double getN(int i,
                            Vector3d coords)
```
  - getdNds
```
public abstract void getdNds(Vector3d dNds,
                             int i,
                             Vector3d coords)
```
  - computeLocalPosition
```
public abstract void computeLocalPosition(Vector3d pnt,
                                          Vector3d ncoords)
```
    Compute position within element based on natural coordinates
    
    Parameters:
    
    pnt - position within element
    
    ncoords - natural coordinates
  - computeJacobian
```
public abstract void computeJacobian(Matrix3d J,
                                     Vector3d ncoords)
```
  - connectToHierarchy
```
public void connectToHierarchy(CompositeComponent hcomp)
```
    Description copied from class: ModelComponentBase
    
    Called by the system after this component, or an ancestor of this component, is added to the component hierarchy (i.e., added as a child of another CompositeComponent). This method is responsible for doing any required hierarchy-dependent initialization, including any updating of referenced components.
    When this method is called, ModelComponent.getParent() will return the new parent component; the system will have set this beforehand.
    
    Specified by:
    
    connectToHierarchy in interface ModelComponent
    
    Overrides:
    
    connectToHierarchy in class ModelComponentBase
    
    Parameters:
    
    hcomp - hierarchy component to which this component, or its ancestor, was attached
  - disconnectFromHierarchy
```
public void disconnectFromHierarchy(CompositeComponent hcomp)
```
    Description copied from class: ModelComponentBase
    
    Called by the system after this component, or an ancestor of this component, is removed from the component hierarchy (i.e., removed as a child of its parent). This method is responsible for any required hierarchy-dependent deinitialization, including any updating of referenced components.
    When this method is called, ModelComponent.getParent() will still return this original parent component; the system will set this to null after.
    
    Specified by:
    
    disconnectFromHierarchy in interface ModelComponent
    
    Overrides:
    
    disconnectFromHierarchy in class ModelComponentBase
    
    Parameters:
    
    hcomp - hierarchy component from which this component, or its ancestor, was detached
  - computeCovariance
```
public double computeCovariance(Matrix3d C)
```
    Description copied from interface: Boundable
    Computes the covariance of the element, assuming a uniform density of one. The covariance is defined as
```
 int_V \rho x x^T dV,
 
```
    where \rho is the density, x is any spatial point within the element, and the integral is evaluated over the element's spatial extent. The method returns the element's spatial size, which for elements of dimension 3, 2, 1, or 0 will be a volume, area, length, or discrete value.
    Implementation of this method is optional, with non-implementation indicated by having the method return -1. Non-implementation may prevent the element from being enclosed within certain types of oriented bounding box (OBB) constructions.
    Specified by:
    
    computeCovariance in interface Boundable
    
    Overrides:
    
    computeCovariance in class FemElement
    
    Parameters:
    
    C - returns the covariance
    
    Returns:
    
    spatial size of the element, or -1 if this method is not implemented.
  - getCopyReferences
```
public boolean getCopyReferences(java.util.List<ModelComponent> refs,
                                 ModelComponent ancestor)
```
    Collects external references which must also be copied in order to duplicate this component. These references should exclude those which are contained within a specified component hierarchy. This method should return true if and only if CopyableComponent.isDuplicatable() returns true.
    
    Specified by:
    
    getCopyReferences in interface CopyableComponent
    
    Overrides:
    
    getCopyReferences in class FemElement
    
    Parameters:
    
    refs - list to which references are appended
    
    ancestor - root node of the hierarchy from which references are to be excluded
    
    Returns:
    
    false if it is discovered that the component cannot be duplicated
  - copy
```
public FemElement3dBase copy(int flags,
                             java.util.Map<ModelComponent,ModelComponent> copyMap)
```
    Description copied from interface: CopyableComponent
    
    Create a copy of this component. If COPY_REFERENCES is set in flags, then any component referenced by this component should itself be set to a copy. This should be done first checking copyMap for an existing copy of the referenced component. If there is no existing copy, then a copy should be created by calling copy recursively and adding the new copy to copyMap.
    
    Specified by:
    
    copy in interface CopyableComponent
    
    Overrides:
    
    copy in class FemElement
    
    Parameters:
    
    flags - flags to control the copying
    
    copyMap - map to possible existing instances of referenced components
    
    Returns:
    
    copy of this component
  - setFrame
```
public void setFrame(Matrix3dBase M)
```
    Set reference frame information for this element. This can be used for computing anisotropic material parameters. In principle, each integration point can have its own frame information, but this method simply sets the same frame information for all the integration points, storing it in each IntegrationData structure. Setting M to null removes the frame information.
    
    Parameters:
    
    M - frame information (is copied by the method)
  - getFrame
```
public Matrix3d getFrame()
```
  - renderWidget
```
public abstract void renderWidget(Renderer renderer,
                                  double size,
                                  RenderProps props)
```
  - computeDirectedRenderSize
```
public double computeDirectedRenderSize(Vector3d dir)
```
    Compute size of an element's render coordinates along a specified direction.
  - computeRenderCoordsAndGradient
```
public void computeRenderCoordsAndGradient(Matrix3d F,
                                           float[] coords)
```
    Computes the current coordinates and deformation gradient at the warping point, using render coordinates. This is used in element rendering.
    
    Parameters:
    
    F - returns the deformation gradient
    
    coords - returns the current coordinates
  - createPointAttachment
```
public PointAttachment createPointAttachment(Point pnt)
```
    Returns a PointAttachment that attaches pnt to this component. It should not be assumed that pnt is currently connected to the component hierarchy, and no attempt should be made to connect the returned attachment to the hierarchy; the latter, if desired, is the responsibility of the caller.
    In some cases, it may not be possible to attach the point at its present location. In that case, the method will create an attachment to the nearest feasible location.
    
    Specified by:
    
    createPointAttachment in interface PointAttachable
    
    Parameters:
    
    pnt - point for which an attachment should be created
    
    Returns:
    
    attachment connecting pnt to this component
  - createFrameAttachment
```
public FrameFem3dAttachment createFrameAttachment(Frame frame,
                                                  RigidTransform3d TFW)
```
    Returns a FrameAttachment that attaches a frame to this component. Once attached the frame will follow the body around. The initial pose of the frame is specified by TFW, which gives its position and orientation in world coordinates. If TFW is null, then the current pose of the frame is used. If frame is null, then a virtual attachment is created at the initial pose specified by TFW. frame and TFW cannot both be null.
    In some cases, it may not be possible to attach the frame at the requested location. In that case, the method will relocate the frame to the nearest feasible attachment location.
    
    Specified by:
    
    createFrameAttachment in interface FrameAttachable
    
    Parameters:
    
    frame - frame to be attached
    
    TFW - transform from (initial) frame coordinates to world coordinates
    
    Returns:
    
    attachment connecting frame to this component
  - computeGravityWeights
```
public VectorNd computeGravityWeights()
```
  - computeConsistentMass
```
public MatrixNd computeConsistentMass()
```
  - addConsistentMass
```
public void addConsistentMass(SparseNumberedBlockMatrix M)
```
  - addConsistentGravity
```
public void addConsistentGravity(Vector3d gacc)
```
  - isInvertedAtRest
```
public boolean isInvertedAtRest()
```
    Returns true if the rest position for this element results in a negative Jacobian determinant for at least one integration point.
    
    Returns:
    
    true if the rest position is inverted.
  - advanceState
```
public void advanceState(double t0,
                         double t1)
```
    Description copied from interface: HasNumericState
    
    If HasNumericState.requiresAdvance() and HasNumericState.hasState() both return true, then this method is called each time step by the system integrator to update this component's state. For single step integrators, the method is called once at the start of the integration, with t0 and t1 set to the step's start and end times. For multi-step integrators (such as Runge Kutta), the method is called for each sub-step, with t0 and t1 set to the sub-step's time bounds. Multi-step integrators will also use HasNumericState.getState(maspack.util.DataBuffer) and HasNumericState.setState(maspack.util.DataBuffer) to save and restore state as required.
    
    Specified by:
    
    advanceState in interface HasNumericState
    
    Parameters:
    
    t0 - beginning time associated with the time step or sub-step
    
    t1 - end time associated with the time step or sub-step
  - requiresAdvance
```
public boolean requiresAdvance()
```
    Returns true if the state of this component must be updated each time step using HasNumericState.advanceState(double, double).
    
    Specified by:
    
    requiresAdvance in interface HasNumericState
    
    Returns:
    
    true if advanceState must be called
  - getState
```
public void getState(DataBuffer data)
```
    Description copied from interface: HasNumericState
    
    Saves state information for this component by adding data to the supplied DataBuffer. Existing data in the buffer should not be disturbed.
    
    Specified by:
    
    getState in interface HasNumericState
    
    Parameters:
    
    data - buffer for storing the state values.
  - setState
```
public void setState(DataBuffer data)
```
    Description copied from interface: HasNumericState
    
    Restores the state for this component by reading from the supplied data buffer, starting at the current buffer offsets.
    
    Specified by:
    
    setState in interface HasNumericState
    
    Parameters:
    
    data - buffer containing the state information
  - notifyStateVersionChanged
```
public void notifyStateVersionChanged()
```
    Specified by:
    
    notifyStateVersionChanged in class FemElement

Class FemElement3dBase

Nested Class Summary

Nested classes/interfaces inherited from class artisynth.core.femmodels.FemElement

Nested classes/interfaces inherited from interface artisynth.core.modelbase.ModelComponent

Field Summary

Fields inherited from class artisynth.core.femmodels.FemElement

Fields inherited from class artisynth.core.modelbase.ModelComponentBase

Fields inherited from interface artisynth.core.modelbase.CopyableComponent

Fields inherited from interface maspack.render.IsRenderable

Constructor Summary

Method Summary

Methods inherited from class artisynth.core.femmodels.FemElement

Methods inherited from class artisynth.core.modelbase.RenderableComponentBase

Methods inherited from class artisynth.core.modelbase.ModelComponentBase

Methods inherited from class java.lang.Object

Methods inherited from interface artisynth.core.modelbase.ModelComponent

Methods inherited from interface maspack.properties.HasProperties

Methods inherited from interface maspack.properties.HierarchyNode

Methods inherited from interface artisynth.core.modelbase.PostScannable

Methods inherited from interface maspack.util.Scannable

Methods inherited from interface artisynth.core.modelbase.HasNumericState

Field Detail

myProps

Constructor Detail

FemElement3dBase

Method Detail

getAllPropertyInfo

getElementClass

setElementWidgetSize

getElementWidgetSize

setElementWidgetSizeMode

getElementWidgetSizeMode

getFemModel

getNodeCoords

getNodeMassWeights

getNodeCoords

getNodes

setNodes

getNodeNeighbors

containsNode

getIntegrationCoords

numIntegrationPoints

getIntegrationPoints

numAllIntegrationPoints

getAllIntegrationPoints

createIntegrationPoints

getIntegrationData

invalidateRestData

getRotation

getRotation

getDeformation

getDeformation

getInvB

getInvB

invalidateRotationData

clearRotationData

getWarpingPoint

getWarpingData

setStiffnessWarper

getStiffnessWarper

coordsAreInside

isInside

getMarkerCoordinates

getNaturalCoordinates

getNaturalCoordinates

getNaturalCoordinatesGSS

getNodalAveragingMatrix

getNodalExtrapolationMatrix

getIntegrationShapeMatrix

getEdgeIndices

getFaceIndices

getTriangulatedFaceIndices

triangulateFace

containsEdge

containsFace

containsFace

getFaces

getNumFaces

getN

getdNds