FemElement3d (Artisynth API documentation)

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

All Implemented Interfaces:

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

Direct Known Subclasses:

HexElement, MFreeElement3d, PyramidElement, QuadhexElement, QuadpyramidElement, QuadtetElement, QuadwedgeElement, TetElement, WedgeElement
```
public abstract class FemElement3d
extends FemElement
implements Boundable, PointAttachable, FrameAttachable
```

Nested Class Summary
- 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.modelbase.ModelComponentBase
  enforceUniqueCompositeNames, enforceUniqueNames, myNumber, NULL_OBJ, useCompactPathNames
- Fields inherited from interface artisynth.core.modelbase.CopyableComponent
  COPY_REFERENCES
- 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

FemElement3d()

Constructors
Constructor and Description
`FemElement3d()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addAuxiliaryMaterial(AuxiliaryMaterial mat)`
`void`	`addNodeForce(Vector3d f, int i, boolean corotated)` Deprecated.
`void`	`addNodeStiffness(int i, int j, boolean corotated)` Deprecated.
`void`	`clearState()`
`void`	`computeCentroid(Vector3d centroid)` Computed the centroid of this element.
`double`	`computeCovariance(Matrix3d C)` Computes the covariance of the element, assuming a uniform density of one.
`double`	`computeDirectedRenderSize(Vector3d dir)`
`VectorNd`	`computeGravityWeights()`
`void`	`computeJacobian(Vector3d s, Matrix3d J)`
`void`	`computePosition(Point3d pnt, Vector3d coords)` Compute position within element based on natural coordinates
`void`	`computePressures(double[] pressures, IncompressibleMaterial imat)`
`void`	`computeRenderCoordsAndGradient(Matrix3d F, float[] coords)` Computes the current coordinates and deformation gradient at the warping point, using render coordinates.
`double`	`computeRestVolumes()` Default method to compute the element rest volume and partial volumes.
`double`	`computeVolumes()` Default method to compute an element's volume and partial volumes.
`void`	`computeWarping(Matrix3d F, SymmetricMatrix3d P)` Deprecated.
`void`	`connectToHierarchy()` Called by the system after this component is added to the component hierarchy (i.e., when it is added as a child of another CompositeComponent).
`abstract boolean`	`coordsAreInside(Vector3d coords)`
`FemElement3d`	`copy(int flags, java.util.Map<ModelComponent,ModelComponent> copyMap)` Create a copy of this component.
`static FemElement3d`	`createElement(FemNode3d[] nodes)`
`static FemElement3d`	`createElement(FemNode3d[] nodes, boolean flipped)`
`FrameFem3dAttachment`	`createFrameAttachment(Frame frame, RigidTransform3d TFW)` Returns a FrameAttachment that attaches a `frame` to this component.
`static IntegrationPoint3d[]`	`createIntegrationPoints(FemElement3d exampleElem, double[] cdata)`
`PointAttachment`	`createPointAttachment(Point pnt)` Returns a PointAttachment that attaches `pnt` to this component.
`void`	`disconnectFromHierarchy()` Called by the system after this component is removed from the component hierarchy (i.e., when it is removed as a child of its parent).
`PropertyList`	`getAllPropertyInfo()` Returns a list giving static information about all properties exported by this object.
`AuxiliaryMaterial[]`	`getAuxiliaryMaterials()`
`boolean`	`getCopyReferences(java.util.List<ModelComponent> refs, ModelComponent ancestor)` Collects external references which must also be copied in order to duplicate this component.
`abstract void`	`getdNds(Vector3d dNds, int i, Vector3d coords)`
`abstract int[]`	`getEdgeIndices()`
`double`	`getElementWidgetSize()`
`PropertyMode`	`getElementWidgetSizeMode()`
`abstract int[]`	`getFaceIndices()`
`FaceNodes3d[]`	`getFaces()` Returns an array of FaceNodes3d describing a set of faces associated with this element.
`Matrix3d`	`getFrame()`
`double`	`getH(int i, Vector3d coords)` Returns the value of the pressure shape function.
`MatrixBlock[]`	`getIncompressConstraints()` Returns an array of MatrixBlocks to be used as constraints to make the element incompressible.
`int`	`getIncompressIndex()`
`abstract double[]`	`getIntegrationCoords()`
`IntegrationData3d[]`	`getIntegrationData()`
`abstract IntegrationPoint3d[]`	`getIntegrationPoints()`
`double[]`	`getLagrangePressures()` Lagrange pressures array for use with incompressibility
`boolean`	`getMarkerCoordinates(VectorNd coords, 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 interations.
`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.
`boolean`	`getNaturalCoordinatesOld(Vector3d coords, Point3d pnt, int maxIters)`
`int`	`getNaturalCoordinatesStd(Vector3d coords, Point3d pnt, int maxIters)`
`abstract double[]`	`getNodalExtrapolationMatrix()`
`abstract double[]`	`getNodeCoords()`
`void`	`getNodeCoords(Vector3d coords, int nodeIdx)`
`FemNodeNeighbor[][]`	`getNodeNeighbors()`
`FemNode3d[]`	`getNodes()`
`int`	`getNumEdges()`
`int`	`getNumFaces()`
`Point3d`	`getPoint(int idx)` Returns the `idx`-th point associated with this element.
`Matrix`	`getPressureWeightMatrix()` Returns the pressure weight matrix for this element.
`double[]`	`getRestVolumes()` Volumes array for use with incompressibility
`StiffnessWarper3d`	`getStiffnessWarper()` Retrieves the current stiffness warper.
`double[]`	`getVolumes()` Volumes array for use with incompressibility
`IntegrationData3d`	`getWarpingData()`
`abstract IntegrationPoint3d`	`getWarpingPoint()`
`boolean`	`hasEdge(FemNode3d n0, FemNode3d n1)`
`boolean`	`hasFace(FemNode3d n0, FemNode3d n1, FemNode3d n2)`
`boolean`	`hasFace(FemNode3d n0, FemNode3d n1, FemNode3d n2, FemNode3d n3)`
`void`	`invalidateRestData()` Invalidate data that relies on the element's rest position, such as rest Jacobians and the base stiffness for co-rotated stiffness.
`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.
`boolean`	`materialsAreInvertible()` Queries if the effective material for this element, and all auxiliary materials, are defined for non-positive deformation gradients.
`int`	`numAuxiliaryMaterials()`
`abstract int`	`numIntegrationPoints()`
`int`	`numPoints()` Returns the number of points associated with this element, if any, or zero otherwise.
`int`	`numPressureVals()` Returns the number of pressure variables associated with this element.
`boolean`	`removeAuxiliaryMaterial(AuxiliaryMaterial mat)`
`abstract void`	`renderWidget(Renderer renderer, double size, RenderProps props)`
`void`	`scaleDistance(double s)` Scales all distance coordinates.
`void`	`setElementWidgetSize(double size)`
`void`	`setElementWidgetSizeMode(PropertyMode mode)`
`void`	`setFrame(Matrix3dBase M)` Set reference frame information for this element.
`void`	`setIncompressIndex(int idx)`
`void`	`setStiffnessWarper(StiffnessWarper3d warper)` Explicitly sets a stiffness warper
`FemNode3d[][]`	`triangulateFace(FaceNodes3d face)`
`void`	`updateBounds(Vector3d pmin, Vector3d pmax)` Update the minimum and maximum points for this object.

Methods inherited from class artisynth.core.femmodels.FemElement
containsNode, createRenderProps, getDensity, getDensityMode, getEffectiveMaterial, getHardReferences, getIndex, getLocalNodeIndex, getMass, getMaterial, getRestVolume, getSelection, getVolume, hasActiveNodes, hasControllableNodes, integrationPointsInterpolateToNodes, integrationPointsMapToNodes, isDuplicatable, isInverted, isMassExplicit, numberString, numNodes, prerender, propertyChanged, render, render, scaleMass, setDensity, setDensityMode, setIndex, setInverted, setMass, setMassExplicit, setMaterial, updateRestVolumeAndMass

Methods inherited from class artisynth.core.modelbase.RenderableComponentBase
getRenderHints, getRenderProps, isSelectable, numSelectionQueriesNeeded, setRenderProps, 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, hasState, isConnectedToHierarchy, isFixed, isMarked, isSelected, isWritable, makeValidName, makeValidName, notifyParentOfChange, postscan, printReferences, recursivelyContained, recursivelyContains, removeTempFlag, scan, setFixed, setFlag, setMarked, setName, setNavpanelVisibility, setNavpanelVisibility, setNumber, setParent, setSelected, 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, postscan, scan, setFixed, setMarked, setName, setNumber, setParent, setSelected, updateReferences

Methods inherited from interface maspack.properties.HasProperties
getProperty

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

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

- Field Detail
  - myProps
```
public static PropertyList myProps
```
- Constructor Detail
  - FemElement3d
```
public FemElement3d()
```
- 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
  - setElementWidgetSize
```
public void setElementWidgetSize(double size)
```
  - getElementWidgetSize
```
public double getElementWidgetSize()
```
  - setElementWidgetSizeMode
```
public void setElementWidgetSizeMode(PropertyMode mode)
```
  - getElementWidgetSizeMode
```
public PropertyMode getElementWidgetSizeMode()
```
  - getNodes
```
public FemNode3d[] getNodes()
```
    Specified by:
    
    getNodes in class FemElement
  - getNodeNeighbors
```
public FemNodeNeighbor[][] getNodeNeighbors()
```
  - getIncompressIndex
```
public int getIncompressIndex()
```
  - setIncompressIndex
```
public void setIncompressIndex(int idx)
```
  - numPressureVals
```
public int numPressureVals()
```
    Returns the number of pressure variables associated with this element. All of the linear elements have one pressure variable, whereas some of the quadratic elements have more.
    
    Returns:
    
    number of pressure variables.make
  - getH
```
public double getH(int i,
                   Vector3d coords)
```
    Returns the value of the pressure shape function. By default, this method returns 1, corresponding to a single pressure variable with constant value over the entire element. Elements with a larger number of pressure DOFs should override this method to supply the appropriate shape functions.
    
    Parameters:
    
    i - index of the pressure variable; should be less than the value returned by numPressureVals()
    
    coords - coordinates at which the shape function should be evaluated.
    
    Returns:
    
    value of the pressure shape function
  - getPressureWeightMatrix
```
public Matrix getPressureWeightMatrix()
```
    Returns the pressure weight matrix for this element. The pressure weight matrix is given by the inverse of the integral of H^T H, where H is the row vector formed from the pressure shape functions.
    By default, this method returns a pressure weight matrix for the case where there is only one pressure value. Such matrices always have a single value of 1. Elements with a larger number of pressure values should override this method to return a pressure weight matrix appropriate for that element.
    
    Returns:
    
    pressure weight matrix for this element
  - getIncompressConstraints
```
public MatrixBlock[] getIncompressConstraints()
```
    Returns an array of MatrixBlocks to be used as constraints to make the element incompressible. Note this method does not compute values for these constraints; it only returns storage for them.
    There is one block for each node, with each of size 3 x m, where m is the number of pressure degrees-of-freedom (returned by numPressureVals().
    
    Returns:
    
    incompressibility constraints
  - 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
  - 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. This method should be used sparingly since it is computes this result from scratch.
    
    Returns:
    
    true if the rest position is inverted.
  - getNumEdges
```
public int getNumEdges()
```
  - getNumFaces
```
public int getNumFaces()
```
  - 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
  - triangulateFace
```
public FemNode3d[][] triangulateFace(FaceNodes3d face)
```
  - computeCentroid
```
public void computeCentroid(Vector3d centroid)
```
    Description copied from interface: Boundable
    
    Computed the centroid of this element.
    
    Specified by:
    
    computeCentroid in interface Boundable
    
    Parameters:
    
    centroid - returns the computed centroid value.
  - computePosition
```
public void computePosition(Point3d pnt,
                            Vector3d coords)
```
    Compute position within element based on natural coordinates
    
    Parameters:
    
    pnt - populated position within element
    
    coords - natural coordinates
  - 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
    
    Parameters:
    
    C - returns the covariance
    
    Returns:
    
    spatial size of the element, or -1 if this method is not implemented.
  - updateBounds
```
public void updateBounds(Vector3d pmin,
                         Vector3d pmax)
```
    Description copied from interface: IsRenderable
    
    Update the minimum and maximum points for this object. In an x-y-z coordinate system with x directed to the right and y directed upwards, the minimum and maximum points can be thought of as defining the left-lower-far and right-upper-near corners of a bounding cube. This method should only reduce the elements of the minimum point and increase the elements of the maximum point, since it may be used as part of an iteration to determine the bounding cube for several different objects.
    
    Specified by:
    
    updateBounds in interface Boundable
    
    Specified by:
    
    updateBounds in interface IsRenderable
    
    Overrides:
    
    updateBounds in class FemElement
    
    Parameters:
    
    pmin - minimum point
    
    pmax - maximum point
  - numIntegrationPoints
```
public abstract int numIntegrationPoints()
```
  - getIntegrationCoords
```
public abstract double[] getIntegrationCoords()
```
  - getNodalExtrapolationMatrix
```
public abstract double[] getNodalExtrapolationMatrix()
```
  - getN
```
public abstract double getN(int i,
                            Vector3d coords)
```
  - getdNds
```
public abstract void getdNds(Vector3d dNds,
                             int i,
                             Vector3d coords)
```
  - getIntegrationPoints
```
public abstract IntegrationPoint3d[] getIntegrationPoints()
```
  - getWarpingPoint
```
public abstract IntegrationPoint3d getWarpingPoint()
```
  - getEdgeIndices
```
public abstract int[] getEdgeIndices()
```
  - getFaceIndices
```
public abstract int[] getFaceIndices()
```
  - getIntegrationData
```
public IntegrationData3d[] getIntegrationData()
```
  - clearState
```
public void clearState()
```
  - getWarpingData
```
public IntegrationData3d getWarpingData()
```
  - createIntegrationPoints
```
public static IntegrationPoint3d[] createIntegrationPoints(FemElement3d exampleElem,
                                                           double[] cdata)
```
  - connectToHierarchy
```
public void connectToHierarchy()
```
    Description copied from class: ModelComponentBase
    
    Called by the system after this component is added to the component hierarchy (i.e., when it is added as a child of another CompositeComponent). This method is responsible for doing any required hierarchy-dependent initialization.
    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
  - 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
  - disconnectFromHierarchy
```
public void disconnectFromHierarchy()
```
    Description copied from class: ModelComponentBase
    
    Called by the system after this component is removed from the component hierarchy (i.e., when it is removed as a child of its parent). This method is responsible for any required hierarchy-dependent deinitialization.
    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
  - coordsAreInside
```
public abstract boolean coordsAreInside(Vector3d coords)
```
  - getMarkerCoordinates
```
public boolean getMarkerCoordinates(VectorNd coords,
                                    Point3d pnt,
                                    boolean checkInside)
```
    Overrides:
    
    getMarkerCoordinates in class FemElement
  - getNodeCoords
```
public abstract double[] getNodeCoords()
```
  - getNodeCoords
```
public void getNodeCoords(Vector3d coords,
                          int nodeIdx)
```
  - getNaturalCoordinates
```
public boolean getNaturalCoordinates(Vector3d coords,
                                     Point3d pnt)
```
    Calls getNaturalCoordinates(Vector3d,Point3d,int) with a default maximum number of interations.
    
    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.
  - getNaturalCoordinatesStd
```
public int getNaturalCoordinatesStd(Vector3d coords,
                                    Point3d pnt,
                                    int maxIters)
```
  - getNaturalCoordinatesOld
```
public boolean getNaturalCoordinatesOld(Vector3d coords,
                                        Point3d pnt,
                                        int maxIters)
```
  - computeVolumes
```
public double computeVolumes()
```
    Default method to compute an element's volume and partial volumes. Uses quadrature. If the number of pressure values is 1, then there is only one partial rest volume which is equal to the overall rest volume. The volume at each quadrature point is also stored in the dv field of the elements integration data, for possible future use.
    The method should return the minimum Jacobian value found when computing the volume for this element. A negative value indicates element inversion.
    Individual elements can override this with a more efficient method if needed.
    
    Specified by:
    
    computeVolumes in class FemElement
    
    Returns:
    
    minimum Jacobian value resulting from volume computation
  - computeJacobian
```
public void computeJacobian(Vector3d s,
                            Matrix3d J)
```
  - getVolumes
```
public double[] getVolumes()
```
    Volumes array for use with incompressibility
    
    Returns:
    
    current volumes
  - computePressures
```
public void computePressures(double[] pressures,
                             IncompressibleMaterial imat)
```
  - getLagrangePressures
```
public double[] getLagrangePressures()
```
    Lagrange pressures array for use with incompressibility
    
    Returns:
    
    pressures
  - computeRestVolumes
```
public double computeRestVolumes()
```
    Default method to compute the element rest volume and partial volumes. Uses quadrature. If the number of pressure values is 1, then there is only one partial rest volume which is equal to the overall rest volume. Individual elements can override this with a more efficient method if needed.
    
    Returns:
    
    element rest volume
  - getRestVolumes
```
public double[] getRestVolumes()
```
    Volumes array for use with incompressibility
    
    Returns:
    
    rest volumes
  - addNodeStiffness
```
@Deprecated
public void addNodeStiffness(int i,
                                         int j,
                                         boolean corotated)
```
    Deprecated.
  - addNodeForce
```
@Deprecated
public void addNodeForce(Vector3d f,
                                     int i,
                                     boolean corotated)
```
    Deprecated.
  - setStiffnessWarper
```
public void setStiffnessWarper(StiffnessWarper3d warper)
```
    Explicitly sets a stiffness warper
    
    Parameters:
    
    warper - new stiffness warper to use
  - getStiffnessWarper
```
public StiffnessWarper3d getStiffnessWarper()
```
    Retrieves the current stiffness warper. The warper's cached rest stiffness is updated if necessary
    
    Returns:
    
    stiffness warper
  - materialsAreInvertible
```
public boolean materialsAreInvertible()
```
    Queries if the effective material for this element, and all auxiliary materials, are defined for non-positive deformation gradients.
    
    Returns:
    
    true if the materials associated with this element are invertible
  - computeWarping
```
@Deprecated
public void computeWarping(Matrix3d F,
                                       SymmetricMatrix3d P)
```
    Deprecated.
  - renderWidget
```
public abstract void renderWidget(Renderer renderer,
                                  double size,
                                  RenderProps props)
```
  - computeDirectedRenderSize
```
public double computeDirectedRenderSize(Vector3d dir)
```
  - 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
  - hasEdge
```
public boolean hasEdge(FemNode3d n0,
                       FemNode3d n1)
```
  - hasFace
```
public boolean hasFace(FemNode3d n0,
                       FemNode3d n1,
                       FemNode3d n2)
```
  - hasFace
```
public boolean hasFace(FemNode3d n0,
                       FemNode3d n1,
                       FemNode3d n2,
                       FemNode3d n3)
```
  - addAuxiliaryMaterial
```
public void addAuxiliaryMaterial(AuxiliaryMaterial mat)
```
  - removeAuxiliaryMaterial
```
public boolean removeAuxiliaryMaterial(AuxiliaryMaterial mat)
```
  - numAuxiliaryMaterials
```
public int numAuxiliaryMaterials()
```
  - getAuxiliaryMaterials
```
public AuxiliaryMaterial[] getAuxiliaryMaterials()
```
  - scaleDistance
```
public void scaleDistance(double s)
```
    Description copied from interface: ScalableUnits
    
    Scales all distance coordinates.
    
    Specified by:
    
    scaleDistance in interface ScalableUnits
    
    Overrides:
    
    scaleDistance in class FemElement
    
    Parameters:
    
    s - scaling factor
  - 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
  - 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()
```
  - copy
```
public FemElement3d 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
  - computeGravityWeights
```
public VectorNd computeGravityWeights()
```
  - createElement
```
public static FemElement3d createElement(FemNode3d[] nodes,
                                         boolean flipped)
```
  - createElement
```
public static FemElement3d createElement(FemNode3d[] nodes)
```
  - createPointAttachment
```
public PointAttachment createPointAttachment(Point pnt)
```
    Description copied from interface: PointAttachable
    
    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
  - numPoints
```
public int numPoints()
```
    Description copied from interface: Boundable
    
    Returns the number of points associated with this element, if any, or zero otherwise. If the element has points, then it's spatial extent is assumed to be enclosed within their convex hull. At present, elements that do not have points cannot be enclosed within oriented bounding box (OBB) trees.
    
    Specified by:
    
    numPoints in interface Boundable
    
    Returns:
    
    number of points associated with this element
  - getPoint
```
public Point3d getPoint(int idx)
```
    Description copied from interface: Boundable
    
    Returns the idx-th point associated with this element.
    
    Specified by:
    
    getPoint in interface Boundable
    
    Parameters:
    
    idx - index of the point (must be on the range 0 to Boundable.numPoints()).
    
    Returns:
    
    idx-th point associated with this element. Must not be modified.

Class FemElement3d

Nested Class Summary

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

Field Summary

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 maspack.util.Scannable

Field Detail

myProps

Constructor Detail

FemElement3d

Method Detail

getAllPropertyInfo

setElementWidgetSize

getElementWidgetSize

setElementWidgetSizeMode

getElementWidgetSizeMode

getNodes

getNodeNeighbors

getIncompressIndex

setIncompressIndex

numPressureVals

getH

getPressureWeightMatrix

getIncompressConstraints

isInside

isInvertedAtRest

getNumEdges

getNumFaces

getFaces

triangulateFace

computeCentroid

computePosition

computeCovariance

updateBounds

numIntegrationPoints

getIntegrationCoords

getNodalExtrapolationMatrix

getN

getdNds

getIntegrationPoints

getWarpingPoint

getEdgeIndices

getFaceIndices

getIntegrationData

clearState

getWarpingData

createIntegrationPoints

connectToHierarchy

invalidateRestData

disconnectFromHierarchy

coordsAreInside

getMarkerCoordinates

getNodeCoords

getNodeCoords

getNaturalCoordinates

getNaturalCoordinates

getNaturalCoordinatesGSS

getNaturalCoordinatesStd

getNaturalCoordinatesOld

computeVolumes

computeJacobian

getVolumes

computePressures

getLagrangePressures

computeRestVolumes

getRestVolumes

addNodeStiffness

addNodeForce

setStiffnessWarper