FrameSpring (Artisynth API documentation)

java.lang.Object
- artisynth.core.modelbase.ModelComponentBase
- - artisynth.core.mechmodels.Spring
  - - artisynth.core.mechmodels.FrameSpring

All Implemented Interfaces:

ForceComponent, ForceEffector, ForceTargetComponent, CopyableComponent, HasNumericState, ModelComponent, PostScannable, RenderableComponent, TransformableGeometry, ScalableUnits, java.lang.Cloneable, HasProperties, HierarchyNode, HasRenderProps, IsRenderable, IsSelectable, Renderable, Scannable
```
public class FrameSpring
extends Spring
implements RenderableComponent, ScalableUnits, TransformableGeometry, CopyableComponent, ForceTargetComponent, HasNumericState
```

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

static boolean mySymmetricJacobian
- Fields inherited from class artisynth.core.modelbase.ModelComponentBase
  enforceUniqueCompositeNames, enforceUniqueNames, myNumber, NULL_OBJ, useCompactPathNames
- Fields inherited from interface maspack.render.IsRenderable
  TRANSPARENT, TWO_DIMENSIONAL
- Fields inherited from interface artisynth.core.modelbase.TransformableGeometry
  TG_ARTICULATED, TG_DRAGGER, TG_PRESERVE_ORIENTATION, TG_SIMULATING
- Fields inherited from interface artisynth.core.modelbase.CopyableComponent
  COPY_REFERENCES, REST_POSITION

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

Constructor Summary

Constructors
Constructor and Description
`FrameSpring()`
`FrameSpring(java.lang.String name)`
`FrameSpring(java.lang.String name, double k, double kRot, double d, double dRot)`
`FrameSpring(java.lang.String name, FrameMaterial mat)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`addForcePosJacobian(SparseBlockMatrix J, double h, boolean staticOnly, int bi)` Add a row to the force Jacobian for this force target component.
`int`	`addForceVelJacobian(SparseBlockMatrix J, double h, int bi)`
`void`	`addPosJacobian(SparseNumberedBlockMatrix M, double s)` Scales the components of the position Jacobian associated with this force effector and adds it to the supplied solve matrix M.
`void`	`addPosJacobianWorld(SparseNumberedBlockMatrix M, double s)`
`void`	`addSolveBlocks(SparseNumberedBlockMatrix M)` Adds any needed blocks to a solve matrix in order to accomodate the Jacobian terms associated with this force effector.
`void`	`addTransformableDependencies(TransformGeometryContext context, int flags)` Adds to `context` any transformable components which should be transformed as the same time as this component.
`void`	`addVelJacobian(SparseNumberedBlockMatrix M, double s)` Scales the components of the velocity Jacobian associated with this force effector and adds it to the supplied solve matrix M.
`void`	`addVelJacobianWorld(SparseNumberedBlockMatrix M, double s)`
`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`	`applyForces(double t)` Adds forces to the components affected by this force effector at a particular time.
`void`	`computeVelJacobianWorld(FrameMaterial mat, double sd, Matrix6d blk00, Matrix6d blk01, Matrix6d blk10, Matrix6d blk11)`
`ModelComponent`	`copy(int flags, java.util.Map<ModelComponent,ModelComponent> copyMap)` Create a copy of this component.
`static FrameMaterial`	`createDefaultMaterial()`
`RenderProps`	`createRenderProps()` Factory method to create render properties appropriate to this object.
`PropertyList`	`getAllPropertyInfo()` Returns a list giving static information about all properties exported by this object.
`RigidTransform3d`	`getAttachFrameA()`
`RigidTransform3d`	`getAttachFrameB()`
`int`	`getAuxVarDerivative(double[] buf, int idx)` If this component has auxiliary variables, returns the current values of their derivatives in `buf`, starting at the location `idx`.
`int`	`getAuxVarState(double[] buf, int idx)` If this component has auxiliary variables, returns their values in `buf`, starting at the location `idx`.
`double`	`getAxisLength()`
`boolean`	`getCopyReferences(java.util.List<ModelComponent> refs, ModelComponent ancestor)` Collects external references which must also be copied in order to duplicate this component.
`boolean`	`getDrawFrameC()`
`boolean`	`getDrawFrameD()`
`void`	`getForce(VectorNd minf, boolean staticOnly)`
`int`	`getForceSize()`
`Frame`	`getFrameA()`
`Frame`	`getFrameB()`
`void`	`getHardReferences(java.util.List<ModelComponent> refs)` Appends all hard references for this component to a list.
`RigidTransform3d`	`getInitialT21()`
`int`	`getJacobianType()` Returns a code indicating the matrix type that results when the Jacobian terms of this force effector are added to the solve matrix.
`FrameMaterial`	`getMaterial()`
`int`	`getRenderHints()` Returns a bit code giving rendering hints about this renderable.
`RenderProps`	`getRenderProps()` Returns the render properities for this object.
`void`	`getSelection(java.util.LinkedList<java.lang.Object> list, int qid)` Append to `list` the component (or components) associated with the `qid`-th selection query issued by this component's render method.
`Wrench`	`getSpringForce()`
`void`	`getState(DataBuffer data)` Saves state information for this component by adding data to the supplied DataBuffer.
`int`	`getStateVersion()` Returns a version number for this component's state.
`boolean`	`hasState()` Queries if this component has state.
`boolean`	`isDuplicatable()` Returns true if this component can be duplicated.
`boolean`	`isJacobianSymmetric()`
`boolean`	`isSelectable()` Returns true if this object is in fact selectable.
`int`	`numAuxVars()` Returns the number of auxiliary variables associated with this component, or 0 if there are no auxiliary variables.
`int`	`numSelectionQueriesNeeded()` If this selectable manages its own selection (by issuing selection queries within its `render` method), then this method should return the maximum number of selection queries that will be required.
`void`	`prerender(RenderList list)` Called prior to rendering to allow this object to update the internal state required for rendering (such as by caching rendering coordinates).
`void`	`render(Renderer renderer, int flags)` Render this object using the functionality of the supplied `Renderer`.
`boolean`	`requiresAdvance()` Returns `true` if the state of this component must be updated each time step using `HasNumericState.advanceState(double, double)`.
`void`	`scaleDistance(double s)` Scales all distance coordinates.
`void`	`scaleMass(double s)` Scales all mass units.
`void`	`setAttachFrameA(RigidTransform3d X1A)`
`void`	`setAttachFrameB(RigidTransform3d X2B)`
`int`	`setAuxVarState(double[] buf, int idx)` If this component has auxiliary variables, sets them from the values in `buf`, starting at the location `idx`.
`void`	`setAxisLength(double len)`
`void`	`setDrawFrameC(boolean draw)`
`void`	`setDrawFrameD(boolean draw)`
`void`	`setFrameA(Frame frame)`
`void`	`setFrameB(Frame frame)`
`void`	`setFrames(Frame frameA, Frame frameB, RigidTransform3d TDW)`
`void`	`setFrames(Frame frameA, RigidTransform3d T1A, Frame frameB, RigidTransform3d T2B)`
`void`	`setInitialT21()` Set the initialX21 to the current value of the transform from frame 2 to frame 1.
`void`	`setInitialT21(RigidTransform3d X21)`
`void`	`setJacobianSymmetric(boolean symmetric)`
`<T extends FrameMaterial> void`	`setMaterial(T mat)`
`void`	`setRenderProps(RenderProps props)` Assigns a new set of render properties to this object.
`void`	`setRotaryStiffness(double k)`
`void`	`setState(DataBuffer data)` Restores the state for this component by reading from the supplied data buffer, starting at the current buffer offsets.
`void`	`transformGeometry(AffineTransform3dBase X)` Applies an affine transformation to the geometry of this component.
`void`	`transformGeometry(GeometryTransformer gtr, TransformGeometryContext context, int flags)` Transforms the geometry of this component, using the geometry transformer `gtr` to transform its individual attributes.
`void`	`updateBounds(Vector3d pmin, Vector3d pmax)` Update the minimum and maximum points for this object.

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

Methods inherited from interface artisynth.core.modelbase.ModelComponent
connectToHierarchy, disconnectFromHierarchy, getName, getNavpanelVisibility, getNumber, getParent, getSoftReferences, 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

- Field Detail
  - mySymmetricJacobian
```
public static boolean mySymmetricJacobian
```
  - myProps
```
public static PropertyList myProps
```
- Constructor Detail
  - FrameSpring
```
public FrameSpring()
```
  - FrameSpring
```
public FrameSpring(java.lang.String name)
```
  - FrameSpring
```
public FrameSpring(java.lang.String name,
                   double k,
                   double kRot,
                   double d,
                   double dRot)
```
  - FrameSpring
```
public FrameSpring(java.lang.String name,
                   FrameMaterial mat)
```
- 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 ModelComponentBase
    
    Returns:
    
    static information for all exported properties
  - getAxisLength
```
public double getAxisLength()
```
  - setAxisLength
```
public void setAxisLength(double len)
```
  - getDrawFrameD
```
public boolean getDrawFrameD()
```
  - setDrawFrameD
```
public void setDrawFrameD(boolean draw)
```
  - setDrawFrameC
```
public void setDrawFrameC(boolean draw)
```
  - getDrawFrameC
```
public boolean getDrawFrameC()
```
  - setInitialT21
```
public void setInitialT21(RigidTransform3d X21)
```
  - getInitialT21
```
public RigidTransform3d getInitialT21()
```
  - setInitialT21
```
public void setInitialT21()
```
    Set the initialX21 to the current value of the transform from frame 2 to frame 1.
  - getRenderProps
```
public RenderProps getRenderProps()
```
    Description copied from interface: HasRenderProps
    
    Returns the render properities for this object. If no render properties are assigned, this routines returns null.
    
    Specified by:
    
    getRenderProps in interface HasRenderProps
    
    Returns:
    
    current render properties for this object
  - setRenderProps
```
public void setRenderProps(RenderProps props)
```
    Description copied from interface: HasRenderProps
    
    Assigns a new set of render properties to this object. An argument of null will remove render properties from this object.
    
    Specified by:
    
    setRenderProps in interface HasRenderProps
    
    Parameters:
    
    props - new render properties for this object
  - createRenderProps
```
public RenderProps createRenderProps()
```
    Description copied from interface: HasRenderProps
    
    Factory method to create render properties appropriate to this object.
    
    Specified by:
    
    createRenderProps in interface HasRenderProps
    
    Returns:
    
    new render properties for this object
  - prerender
```
public void prerender(RenderList list)
```
    Description copied from interface: IsRenderable
    
    Called prior to rendering to allow this object to update the internal state required for rendering (such as by caching rendering coordinates). The object may add internal objects to the list of objects being rendered, by calling
    list.addIfVisible (obj);
    for each of the objects in question.
    
    Specified by:
    
    prerender in interface IsRenderable
    
    Parameters:
    
    list - list of objects to be rendered
  - 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 IsRenderable
    
    Parameters:
    
    pmin - minimum point
    
    pmax - maximum point
  - getRenderHints
```
public int getRenderHints()
```
    Description copied from interface: IsRenderable
    
    Returns a bit code giving rendering hints about this renderable. Current bit codes include TRANSPARENT and TWO_DIMENSIONAL.
    
    Specified by:
    
    getRenderHints in interface IsRenderable
    
    Returns:
    
    bit code of rendering hints.
  - isSelectable
```
public boolean isSelectable()
```
    Description copied from interface: IsSelectable
    
    Returns true if this object is in fact selectable.
    
    Specified by:
    
    isSelectable in interface IsSelectable
    
    Returns:
    
    true if this object is selectable
  - numSelectionQueriesNeeded
```
public int numSelectionQueriesNeeded()
```
    Description copied from interface: IsSelectable
    
    If this selectable manages its own selection (by issuing selection queries within its render method), then this method should return the maximum number of selection queries that will be required. Otherwise, this method should return -1.
    
    Specified by:
    
    numSelectionQueriesNeeded in interface IsSelectable
    
    Returns:
    
    maximum number of selection queries needed by this component, or -1 if this component does not manage its own selection.
  - render
```
public void render(Renderer renderer,
                   int flags)
```
    Description copied from interface: IsRenderable
    
    Render this object using the functionality of the supplied Renderer.
    
    Specified by:
    
    render in interface IsRenderable
    
    Parameters:
    
    renderer - provides the functionality used to perform the rendering.
    
    flags - flags that may be used to control different aspects of the rendering. Flags are defined in Renderer and currently include Renderer.HIGHLIGHT and Renderer.SORT_FACES.
  - getSelection
```
public void getSelection(java.util.LinkedList<java.lang.Object> list,
                         int qid)
```
    Description copied from interface: IsSelectable
    
    Append to list the component (or components) associated with the qid-th selection query issued by this component's render method. This will only be called if this component manages its own selection (i.e., the number nums returned by IsSelectable.numSelectionQueriesNeeded() is positive), and qid will in turn be a number between 0 and nums-1.
    
    Specified by:
    
    getSelection in interface IsSelectable
    
    Parameters:
    
    list - selected objects are appended to the end of this list
    
    qid - index of the selection query
  - createDefaultMaterial
```
public static FrameMaterial createDefaultMaterial()
```
  - getMaterial
```
public FrameMaterial getMaterial()
```
  - setMaterial
```
public <T extends FrameMaterial> void setMaterial(T mat)
```
  - setRotaryStiffness
```
public void setRotaryStiffness(double k)
```
  - setFrameA
```
public void setFrameA(Frame frame)
```
  - getFrameA
```
public Frame getFrameA()
```
  - setFrameB
```
public void setFrameB(Frame frame)
```
  - getFrameB
```
public Frame getFrameB()
```
  - setAttachFrameA
```
public void setAttachFrameA(RigidTransform3d X1A)
```
  - getAttachFrameA
```
public RigidTransform3d getAttachFrameA()
```
  - setAttachFrameB
```
public void setAttachFrameB(RigidTransform3d X2B)
```
  - getAttachFrameB
```
public RigidTransform3d getAttachFrameB()
```
  - setFrames
```
public void setFrames(Frame frameA,
                      Frame frameB,
                      RigidTransform3d TDW)
```
  - setFrames
```
public void setFrames(Frame frameA,
                      RigidTransform3d T1A,
                      Frame frameB,
                      RigidTransform3d T2B)
```
  - getSpringForce
```
public Wrench getSpringForce()
```
  - applyForces
```
public void applyForces(double t)
```
    Description copied from interface: ForceEffector
    
    Adds forces to the components affected by this force effector at a particular time. Component forces should be added and not set, since other forces may be added to the same components by other force effectors.
    
    Specified by:
    
    applyForces in interface ForceEffector
    
    Specified by:
    
    applyForces in class Spring
    
    Parameters:
    
    t - time (seconds)
  - addPosJacobian
```
public void addPosJacobian(SparseNumberedBlockMatrix M,
                           double s)
```
    Description copied from interface: ForceEffector
    
    Scales the components of the position Jacobian associated with this force effector and adds it to the supplied solve matrix M.
    M is guaranteed to be the same matrix supplied in the most recent call to addSolveBlocks, and so implementations may choose to cache the relevant matrix blocks from that call, instead of retrieving them directly from M.
    
    Specified by:
    
    addPosJacobian in interface ForceEffector
    
    Parameters:
    
    M - solve matrix to which scaled position Jacobian is to be added
    
    s - scaling factor for position Jacobian
  - addPosJacobianWorld
```
public void addPosJacobianWorld(SparseNumberedBlockMatrix M,
                                double s)
```
  - addVelJacobian
```
public void addVelJacobian(SparseNumberedBlockMatrix M,
                           double s)
```
    Description copied from interface: ForceEffector
    
    Scales the components of the velocity Jacobian associated with this force effector and adds it to the supplied solve matrix M.
    M is guaranteed to be the same matrix supplied in the most recent call to addSolveBlocks, and so implementations may choose to cache the relevant matrix blocks from that call, instead of retrieving them directly from M.
    
    Specified by:
    
    addVelJacobian in interface ForceEffector
    
    Parameters:
    
    M - solve matrix to which scaled velocity Jacobian is to be added
    
    s - scaling factor for velocity Jacobian
  - addVelJacobianWorld
```
public void addVelJacobianWorld(SparseNumberedBlockMatrix M,
                                double s)
```
  - computeVelJacobianWorld
```
public void computeVelJacobianWorld(FrameMaterial mat,
                                    double sd,
                                    Matrix6d blk00,
                                    Matrix6d blk01,
                                    Matrix6d blk10,
                                    Matrix6d blk11)
```
  - addSolveBlocks
```
public void addSolveBlocks(SparseNumberedBlockMatrix M)
```
    Description copied from interface: ForceEffector
    
    Adds any needed blocks to a solve matrix in order to accomodate the Jacobian terms associated with this force effector. In general, blocks will be need to be added at locations given by the block indices (bi, bj), where bi and bj correspond to the solve indices (as returned by getSolveIndex) for all dynamic or attached components affected by this force effector.
    
    Specified by:
    
    addSolveBlocks in interface ForceEffector
    
    Parameters:
    
    M - solve matrix to which blocks should be added
  - getForceSize
```
public int getForceSize()
```
    Specified by:
    
    getForceSize in interface ForceTargetComponent
  - getForce
```
public void getForce(VectorNd minf,
                     boolean staticOnly)
```
    Specified by:
    
    getForce in interface ForceTargetComponent
  - addForcePosJacobian
```
public int addForcePosJacobian(SparseBlockMatrix J,
                               double h,
                               boolean staticOnly,
                               int bi)
```
    Description copied from interface: ForceTargetComponent
    Add a row to the force Jacobian for this force target component. The Jacobian maps state velocities u into the forces fm that should be minimized
```
 fm = J u
 
```
    Specified by:
    
    addForcePosJacobian in interface ForceTargetComponent
    
    Parameters:
    
    J - force Jacobian
    
    h - current time step
    
    staticOnly - use only static forces
    
    bi - block row index for the row to be added
    
    Returns:
    
    bi + 1
  - addForceVelJacobian
```
public int addForceVelJacobian(SparseBlockMatrix J,
                               double h,
                               int bi)
```
    Specified by:
    
    addForceVelJacobian in interface ForceTargetComponent
  - transformGeometry
```
public void transformGeometry(AffineTransform3dBase X)
```
    Description copied from interface: TransformableGeometry
    Applies an affine transformation to the geometry of this component. This method should be equivalent to
```
 TransformGeometryContext.transform (this, X, 0);
 
```
    Specified by:
    
    transformGeometry in interface TransformableGeometry
    
    Parameters:
    
    X - affine transformation to apply to the component
  - addTransformableDependencies
```
public void addTransformableDependencies(TransformGeometryContext context,
                                         int flags)
```
    Description copied from interface: TransformableGeometry
    
    Adds to context any transformable components which should be transformed as the same time as this component. This will generally include descendant components, and may also include other components to which this component is connected in some way.
    This method is generally called from with the TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int) method of a TransformGeometryContext.
    
    Specified by:
    
    addTransformableDependencies in interface TransformableGeometry
    
    Parameters:
    
    context - context information, to which the dependent components are added.
    
    flags - specifies conditions associated with the transformation
  - transformGeometry
```
public void transformGeometry(GeometryTransformer gtr,
                              TransformGeometryContext context,
                              int flags)
```
    Description copied from interface: TransformableGeometry
    
    Transforms the geometry of this component, using the geometry transformer gtr to transform its individual attributes. The context argument supplies information about what other components are currently being transformed, and also allows the requesting of update actions to be performed after all transform called have completed. The context is also the usual entity that calls this method, from within its TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int) method. The argument flags provides flags to specify various conditions associated with the the transformation. At present, the available flags are TransformableGeometry.TG_SIMULATING and TransformableGeometry.TG_ARTICULATED.
    This method is not usually called directly by applications. Instead, it is typically called from within the TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int) method of the context, which takes care of the various operations needed for a complete transform operation, including calling TransformableGeometry.addTransformableDependencies(artisynth.core.modelbase.TransformGeometryContext, int) to collect other components that should be transformed, calling TransformableGeometry.transformGeometry(maspack.matrix.AffineTransform3dBase) for each component, notifying component parents that the geometry has changed, and calling any requested TransformGeometryActions. More details are given in the documentation for TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int).
    TransformGeometryContext provides a number of static convenience transform methods which take care of building the context and calling apply() for a specified set of components.
    This method should not generally call transformGeometry() for its descendant components. Instead, descendants needing transformation should be specified by adding them to the context in the method TransformableGeometry.addTransformableDependencies(artisynth.core.modelbase.TransformGeometryContext, int).
    
    Specified by:
    
    transformGeometry in interface TransformableGeometry
    
    Parameters:
    
    gtr - transformer implementing the transform
    
    context - context information, including what other components are being transformed
    
    flags - specifies conditions associated with the transformation
  - scaleDistance
```
public void scaleDistance(double s)
```
    Description copied from interface: ScalableUnits
    
    Scales all distance coordinates.
    
    Specified by:
    
    scaleDistance in interface ScalableUnits
    
    Parameters:
    
    s - scaling factor
  - scaleMass
```
public void scaleMass(double s)
```
    Description copied from interface: ScalableUnits
    
    Scales all mass units.
    
    Specified by:
    
    scaleMass in interface ScalableUnits
    
    Parameters:
    
    s - scaling factor
  - setJacobianSymmetric
```
public void setJacobianSymmetric(boolean symmetric)
```
  - isJacobianSymmetric
```
public boolean isJacobianSymmetric()
```
  - getJacobianType
```
public int getJacobianType()
```
    Description copied from interface: ForceEffector
    
    Returns a code indicating the matrix type that results when the Jacobian terms of this force effector are added to the solve matrix. This should be a logical or-ing of either Matrix.SYMMETRIC or Matrix.POSITIVE_DEFINITE. The former should be set if adding the Jacobian terms preserves symmetry, and the latter should be set if positive definiteness if preserved. Both should be set if there is no Jacobian for this effector (i.e., the Jacobian methods are not implemented). Matrix types from all the force effectors are logically and-ed together to determine the type for the entire solve matrix.
    
    Specified by:
    
    getJacobianType in interface ForceEffector
    
    Returns:
    
    solve matrix type resulting from adding Jacobian terms
  - getHardReferences
```
public void getHardReferences(java.util.List<ModelComponent> refs)
```
    Description copied from class: ModelComponentBase
    
    Appends all hard references for this component to a list. References are other components, outside of this component's immediate ancestry, on which this component depends. For example, an AxialSpring refers to two Point components as for it's end points. A hard reference is one which the referring component must have, and which if deleted, implies that the referring component should be deleted too.
    
    Specified by:
    
    getHardReferences in interface ModelComponent
    
    Overrides:
    
    getHardReferences in class ModelComponentBase
    
    Parameters:
    
    refs - list to which hard references are appended
  - isDuplicatable
```
public boolean isDuplicatable()
```
    Returns true if this component can be duplicated. Duplication means that we can expect to be able to make a complete copy of the component along with all it's external references. This method should return true if and only if CopyableComponent.getCopyReferences(java.util.List<artisynth.core.modelbase.ModelComponent>, artisynth.core.modelbase.ModelComponent) returns true.
    This method is not currently used. It is intended to provide a faster way of determining if a component can be duplicated, without having to use CopyableComponent.getCopyReferences(java.util.List<artisynth.core.modelbase.ModelComponent>, artisynth.core.modelbase.ModelComponent) to build the list of copy references.
    
    Specified by:
    
    isDuplicatable in interface CopyableComponent
    
    Returns:
    
    true if this component can be duplicated.
  - hasState
```
public boolean hasState()
```
    Queries if this component has state. Structure change events involving components that have state will cause the current state history of of the system to be cleared.
    
    Specified by:
    
    hasState in interface HasNumericState
    
    Specified by:
    
    hasState in interface ModelComponent
    
    Overrides:
    
    hasState in class ModelComponentBase
    
    Returns:
    
    true if this component has state
  - getStateVersion
```
public int getStateVersion()
```
    Returns a version number for this component's state. When the version number changes, any previously saved state should be considered no longer compatible. The default implementation of this method always returns 0, indicating that state compatibility never changes.
    
    Specified by:
    
    getStateVersion in interface HasNumericState
  - getState
```
public void getState(DataBuffer data)
```
    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)
```
    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
  - 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
  - advanceState
```
public 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. 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
  - numAuxVars
```
public int numAuxVars()
```
    Returns the number of auxiliary variables associated with this component, or 0 if there are no auxiliary variables.
    If HasNumericState.hasState() returns true and the component has auxiliary variables, the variables are updated each time step by the system integrator using explcit integration of the form
```
 w += h dwdt
 
```
    where h is a time increment, w is a vector of variables accessed using HasNumericState.getAuxVarState(double[], int) and HasNumericState.setAuxVarState(double[], int), and dwdt is a time derivative obtained using HasNumericState.getAuxVarDerivative(double[], int). For single step integrators, this will be done once at the start of the integration, with h set to the time step size. For multi-step integrators (such as Runge Kutta), this will be done at the start of each sub-step, with h set to the sub-step size.
    If present, auxiliary variables are also assumed to be contained within the state accessed using HasNumericState.getState(maspack.util.DataBuffer) and HasNumericState.setState(maspack.util.DataBuffer).
    Specified by:
    
    numAuxVars in interface HasNumericState
    
    Returns:
    
    number of auxiliary variables.
  - getAuxVarState
```
public int getAuxVarState(double[] buf,
                          int idx)
```
    If this component has auxiliary variables, returns their values in buf, starting at the location idx. See HasNumericState.numAuxVars() for a description of auxiliary variables. The method returns idx + num, where num is the number of variables.
    
    Specified by:
    
    getAuxVarState in interface HasNumericState
    
    Parameters:
    
    buf - returns the variable values
    
    idx - starting point within buf
    
    Returns:
    
    idx plus the number of variables
  - setAuxVarState
```
public int setAuxVarState(double[] buf,
                          int idx)
```
    If this component has auxiliary variables, sets them from the values in buf, starting at the location idx. See HasNumericState.numAuxVars() for a description of auxiliary variables. The method returns idx + num, where num is the number of variables.
    
    Specified by:
    
    setAuxVarState in interface HasNumericState
    
    Parameters:
    
    buf - contains the new variable values
    
    idx - starting point within buf
    
    Returns:
    
    idx plus the number of variables
  - getAuxVarDerivative
```
public int getAuxVarDerivative(double[] buf,
                               int idx)
```
    If this component has auxiliary variables, returns the current values of their derivatives in buf, starting at the location idx. See HasNumericState.numAuxVars() for a description of auxiliary variables. The method returns idx + num, where num is the number of variables.
    
    Specified by:
    
    getAuxVarDerivative in interface HasNumericState
    
    Parameters:
    
    buf - returns the variable derivative values
    
    idx - starting point within buf
    
    Returns:
    
    idx plus the number of variables
  - 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
    
    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 ModelComponent 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 ModelComponentBase
    
    Parameters:
    
    flags - flags to control the copying
    
    copyMap - map to possible existing instances of referenced components
    
    Returns:
    
    copy of this component

Class FrameSpring

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 maspack.render.IsRenderable

Fields inherited from interface artisynth.core.modelbase.TransformableGeometry

Fields inherited from interface artisynth.core.modelbase.CopyableComponent

Constructor Summary

Method Summary

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

Field Detail

mySymmetricJacobian

myProps

Constructor Detail

FrameSpring

FrameSpring

FrameSpring

FrameSpring

Method Detail

getAllPropertyInfo

getAxisLength

setAxisLength

getDrawFrameD

setDrawFrameD

setDrawFrameC

getDrawFrameC

setInitialT21

getInitialT21

setInitialT21

getRenderProps

setRenderProps

createRenderProps

prerender

updateBounds

getRenderHints

isSelectable

numSelectionQueriesNeeded

render

getSelection

createDefaultMaterial

getMaterial

setMaterial

setRotaryStiffness

setFrameA

getFrameA

setFrameB

getFrameB

setAttachFrameA

getAttachFrameA

setAttachFrameB

getAttachFrameB

setFrames

setFrames

getSpringForce

applyForces

addPosJacobian

addPosJacobianWorld

addVelJacobian

addVelJacobianWorld

computeVelJacobianWorld

addSolveBlocks

getForceSize

getForce

addForcePosJacobian

addForceVelJacobian

transformGeometry

addTransformableDependencies

transformGeometry

scaleDistance

scaleMass

setJacobianSymmetric

isJacobianSymmetric

getJacobianType