MultiPointSpring (Artisynth API documentation)

java.lang.Object
- artisynth.core.modelbase.ModelComponentBase
- - artisynth.core.mechmodels.Spring
  - - artisynth.core.mechmodels.PointSpringBase
    - - artisynth.core.mechmodels.MultiPointSpring

All Implemented Interfaces:

ForceComponent, ForceEffector, HasSlaveObjects, RequiresPrePostAdvance, CopyableComponent, HasNumericState, ModelComponent, PostScannable, RenderableComponent, TransformableGeometry, ScalableUnits, java.lang.Cloneable, HasProperties, HierarchyNode, HasRenderProps, IsRenderable, IsSelectable, Renderable, Scannable

Direct Known Subclasses:

MultiPointMuscle
```
public class MultiPointSpring
extends PointSpringBase
implements ScalableUnits, TransformableGeometry, CopyableComponent, RequiresPrePostAdvance, HasSlaveObjects
```
Multi-segment point-based spring that supports supports wrapping of selected segments.
A multipoint spring is divided into one or more segments, each separated by a single point and represented by a MultiPointSpring.Segment.
Segments may optionally by made wrappable, allowing them to wrap around any of the Wrappable objects known the spring. Wrappable segments are represented by the MultiPointSpring.WrapSegment subclass of MultiPointSpring.Segment. Each wrappable segment is implemented using a prescribed number of knot points (typically 50-100), which are drawn tightly around the wrappable objects using fictitious wrap forces which pull them together and contact forces that repel them from the wrappables. The process of determining the wrap path is done using a Newton-based iteration inside the MultiPointSpring.WrapSegment.updateWrapStrand(int) method of MultiPointSpring.WrapSegment.
When a WrapSegment makes contact with one or more wrappables, is dynamically partitioned into two or more subsegments separating the contacting wrappables and the spring start and end points. More specifically, assume that the segment is in contact with n wrappables, identified by W_j for 0 <= j < n. Then the segment will be divided into n + 1 subsegments, where
- The first subsegment describes the line segment between the spring starting point and the first contact point on W_0;
- The intermediate subsegmenti describes the line segment between the last contact point on W_{i-1} and the first contact point on W_i;
- The last subsegment describes the line segment between the last contact point on W_{n-1} and the spring end point.
During simulation, forces are imparted from the spring to each contacting wrappable via A/B points, which represent the locations at which the spring first makes contact (A point) and finally breaks contact (B point) with the wrappable. The A/B points are associated with the subsegments of each wrappable segment, and are computed dynamically when the subsegments are computed, which happens inside the MultiPointSpring.WrapSegment.updateSubSegments() method of MultiPointSpring.WrapSegment.
The computation of the wrap path and the updating of the subsegments for all wrappable segments occurs inside updateWrapSegments(int), which is initially called at time 0 (before any simulation steps) inside preadvance(double, double, int), and subsequently after each simulation step inside postadvance(double, double, int).

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`MultiPointSpring.Segment` Stores information for the segments of this spring.
`static class`	`MultiPointSpring.SegmentSpec` Stores specification information for the segments of this spring.
`class`	`MultiPointSpring.SubSegment` Contains subsegment information.
`class`	`MultiPointSpring.WrapKnot` Stores information for a single knot point in a wrappable segment.
`class`	`MultiPointSpring.WrapSegment` Implements a wrappable segment.

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

Field Summary

Fields
Modifier and Type	Field and Description
`double`	`maxForceNorm`
`double`	`maxLengthErr`
`static boolean`	`myDrawWrapPoints`
`static PropertyList`	`myProps`
`double`	`sumForceNorm`
`double`	`sumLengthErr`
`int`	`totalCalls`
`int`	`totalFails`
`int`	`totalFalseStuck`
`int`	`totalStuck`

Fields inherited from class artisynth.core.mechmodels.PointSpringBase
myIgnoreCoriolisInJacobian, useMaterial

Fields inherited from class artisynth.core.modelbase.ModelComponentBase
enforceUniqueCompositeNames, enforceUniqueNames, myNumber, NULL_OBJ, useCompactPathNames

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 inherited from interface maspack.render.IsRenderable
TRANSPARENT, TWO_DIMENSIONAL

Constructor Summary

Constructors
Constructor and Description
`MultiPointSpring()` Constructs an empty multipoint spring.
`MultiPointSpring(double k, double d, double l0)` Constructs an empty multipoint spring initialized with a linear axial material.
`MultiPointSpring(java.lang.String name)` Constructs an empty multipoint spring with a name.
`MultiPointSpring(java.lang.String name, double k, double d, double l0)` Constructs an empty multipoint spring with a name and initialized with a linear axial material.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addPoint(int idx, Point pnt)` Adds a point to this spring at a specified index.
`void`	`addPoint(Point pnt)` Adds a point to this spring.
`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`	`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`	`addWrappable(Wrappable wrappable)` Adds a wrappable to this spring which is applied to all wrap segments.
`void`	`addWrappable(Wrappable wrappable, int pntIdx0, int pntIdx1)` Adds a wrappable to this spring which is applied to the segments between the points indexed by `pntIdx0` and `pntIdx1`.
`void`	`applyForces(double t)` Applies forces to the points of this spring, as well as any wrappables that are in contact with wrappable segments, resulting from the tension in the spring.
`void`	`clearPoints()` Removes all points (and segments) from this spring.
`void`	`clearWrappables()` Removes all wrappables from this spring
`boolean`	`clearWrappableSegment(int segIdx)`
`boolean`	`containsPoint(Point pnt)` Queries whether this spring contains a specified points.
`boolean`	`containsWrappable(Wrappable wrappable)` Queries whether or not this spring contains a wrappable for which wrapping is applied to all segments.
`boolean`	`containsWrappable(Wrappable wrappable, int pntIdx0, int pntIdx1)` Queries whether or not this spring contains a wrappable which is applied to the segments between the points indexed by `pntIdx0` and `pntIdx1`.
`ModelComponent`	`copy(int flags, java.util.Map<ModelComponent,ModelComponent> copyMap)` Makes a copy of this spring.
`java.awt.Color`	`getABPointColor()` Queries the color to be used for rendering A/B points.
`double`	`getActiveLength()` Computes the active length of this spring, corresponding to the length of all the active segments.
`double`	`getActiveLengthDot()` Computes the derivative of the active length of this spring.
`int`	`getAllABPoints(java.util.ArrayList<Point> pnts)` Returns all the AB points which are currently active on the segments.
`PropertyList`	`getAllPropertyInfo()` Returns a list giving static information about all properties exported by this object.
`int`	`getContactCount()` When profiling is enabled, returns the total number of times that the wrap path was in contact.
`double`	`getContactDamping()` Queries the the contact damping for this spring.
`java.awt.Color`	`getContactingKnotsColor()` Queries the color, if any, used for rendering knots that are in contact, or `null` if no such color is specified.
`double`	`getContactStiffness()` Queries the contact stiffness for this spring.
`int`	`getConvergedCount()` When profiling is enabled, returns the total number of times that the wrap path solution converged.
`double`	`getConvergenceTol()` Queries the convergence tolerance for this spring.
`boolean`	`getCopyReferences(java.util.List<ModelComponent> refs, ModelComponent ancestor)` Does nothing and returns `false`, since copying of MultiPointSpring is not currently implemented.
`int`	`getDebugLevel()` Gets the debug level for this spring.
`boolean`	`getDrawABPoints()` Queries whether drawing A/B points is enabled for this spring.
`double`	`getDrawDisplacements()`
`boolean`	`getDrawKnots()` Queries whether knot rendering is enabled for this spring.
`void`	`getHardReferences(java.util.List<ModelComponent> refs)` Appends all hard references for this component to a list.
`int`	`getIterationCount()` When profiling is enabled, returns the cummulative number of iterations for updating all wrap paths.
`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.
`MultiPointSpring.WrapKnot`	`getKnot(int segIdx, int k)` Returns the `k`-th knot in the current segment indexed by `segIdx`.
`double`	`getLength()` Computes the length of this spring.
`double`	`getLengthDot()` Computes the derivative of the length of this spring.
`boolean`	`getLineSearch()` Queries whether line search is enabled for this spring.
`double`	`getMaxWrapDisplacement()` Queries the maximum wrap displacement for this spring.
`int`	`getMaxWrapIterations()` Queries the maximum number of wrap iterations for this spring.
`Point`	`getPoint(int idx)` Returns the `idx`-th point in this spring.
`boolean`	`getPrintProfiling()` Queries whether printing profile timing information is enabled for this spring.
`int`	`getProfileCount()` When profiling is enabled, returns the total number of times a wrap path has been updated.
`double`	`getProfileTimeUsec()` When profiling is enabled, returns the averge compute time required to update each wrap path.
`boolean`	`getProfiling()` Queries whether the collection of profiling information is enabled for this spring.
`MultiPointSpring.Segment`	`getSegment(int segIdx)` Returns the curren segment indexed by `segIdx` in this spring.
`MultiPointSpring.SegmentSpec`	`getSegmentSpec(int segIdx)` Returns the segment indexed by `segIdx` in this spring.
`void`	`getSoftReferences(java.util.List<ModelComponent> refs)` Appends all soft references for this component to a list.
`double`	`getSor()` Gets the successive overrelaxation parameter for this spring.
`void`	`getState(DataBuffer data)` Saves state information for this component by adding data to the supplied DataBuffer.
`int`	`getUpdateContactsCount()` When profiling is enabled, returns the cummulative number of contact detection operations for all wrappable segment updates.
`double`	`getWrapDamping()` Queries the wrap damping for this spring.
`double`	`getWrapKnotDensity()` Returns the default knot density for wrapping strands.
`PropertyMode`	`getWrapKnotDensityMode()`
`Wrappable`	`getWrappable(int idx)` Returns the idx-th wrappable in this spring.
`int[]`	`getWrappableRange(int idx)` Returns the point indices defining the wrappable range for the idx-th wrappable in this spring.
`double`	`getWrapStiffness()` Queries the wrap stiffness for this spring.
`boolean`	`hasConditionalPoints()`
`boolean`	`hasMovingMarkers()`
`boolean`	`hasState()` Queries if this component has state.
`boolean`	`hasWrappableSegments()`
`int`	`indexOfPoint(Point pnt)` Returns the index of a specified point in this spring, or -1 if the point is not present.
`int`	`indexOfWrappable(Wrappable wrappable)` Returns the index of a wrappable in this spring which is applied to all segments, or -1 if such a wrappable is not present.
`int`	`indexOfWrappable(Wrappable wrappable, int pntIdx0, int pntIdx1)` Returns the index of a wrappable in this spring which is applied to the segments between the points indexed by `pntIdx0` and `pntIdx1`.
`void`	`initializeSegment(int segIdx, Point3d[] initialPnts)` Initializes the wrap path for the wrappable segment indexed by `segIdx`, using a specified set of initialization points.
`boolean`	`isDuplicatable()` Returns `false`, since copying of MultiPointSpring is not currently implemented.
`boolean`	`isSegmentPassive(int segIdx)` Queries whether the segment indexed by `segIdx` is passive.
`static void`	`main(java.lang.String[] args)`
`int`	`numKnots(int segIdx)` Queries the number of knots in the current segment indexed by `segIdx`.
`int`	`numPassiveSegments()` Queries the number of passive segments in this spring.
`int`	`numPoints()` Queries the number of points in this spring.
`int`	`numSegments()` Returns the current number of segments in this spring.
`int`	`numSegmentSpecs()` Returns the number of specified segment in this spring.
`int`	`numWrappables()` Queries the number of wrappables specified in this spring.
`java.lang.String`	`pathWrapString()`
`void`	`postadvance(double t0, double t1, int flags)` Called from within the model's `advance()` method, after all position and velocity state has been advanced.
`void`	`postscan(java.util.Deque<ScanToken> tokens, CompositeComponent ancestor)` Performs any required post-scanning for this component.
`void`	`preadvance(double t0, double t1, int flags)` Called from within the model's {`advance()` method, before position and velocity states are advanced.
`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).
`boolean`	`removePoint(Point pnt)` Removes a point (and the corresponding segment, if the point is not the first point) from this spring.
`boolean`	`removeWrappable(Wrappable wrappable)` Remove from this spring a wrappable which is applied to all segments.
`boolean`	`removeWrappable(Wrappable wrappable, int pntIdx0, int pntIdx1)` Remove from this spring a wrappable which is applied to the segments between the points indexed by `pntIdx0` and `pntIdx1`.
`void`	`render(Renderer renderer, int flags)` Render this object using the functionality of the supplied `Renderer`.
`void`	`scaleDistance(double s)` Scales all distance coordinates.
`void`	`scaleMass(double s)` Scales all mass units.
`void`	`scan(ReaderTokenizer rtok, java.lang.Object ref)` Scans this element from a ReaderTokenizer.
`void`	`setABPointColor(java.awt.Color color)` Sets the color to be used for rendering A/B points.
`void`	`setAllSegmentsWrappable(int numk)` Sets all segments in this spring to be wrappable with a specified number of knots.
`void`	`setContactDamping(double damping)` Sets the contact damping for this spring.
`void`	`setContactingKnotsColor(java.awt.Color color)` Sets a special color that should be used for rendering knots that are in contact.
`void`	`setContactStiffness(double stiffness)` Sets the contact stiffness for this spring.
`void`	`setConvergenceTol(double tol)` Sets the convergence tolerance `tol` for this spring.
`void`	`setDebugLevel(int level)` Sets the debug level for this spring.
`void`	`setDrawABPoints(boolean enable)` Enables or disables drawing A/B points for this spring.
`void`	`setDrawDisplacements(double scale)`
`void`	`setDrawKnots(boolean enable)` Enables or disables knot rendering for this spring.
`void`	`setKnotPositions(int segIdx, Point3d[] plist)` Sets the knot positions for a wrappable current segment indxed by `segIdx`.
`void`	`setLineSearch(boolean enable)` Enables or disables line search for this spring.
`void`	`setMaxWrapDisplacement(double d)` Sets the maximum wrap displacement for this spring.
`void`	`setMaxWrapIterations(int num)` Sets the maximum number of wrap iterations for this spring.
`void`	`setPrintProfiling(boolean enabled)` Enables or disables the printing of profile timing information for this spring.
`void`	`setProfiling(boolean enabled)` Enables or disables the collection of profiling information for this spring.
`double`	`setRestLengthFromPoints()` Sets the rest length of the spring from the current point locations
`void`	`setSegmentPassive()` Sets the current spring segment (the one following the most recently added point) to be passive, meaning that its length is not included as part of the spring's active length.
`void`	`setSegmentPassive(int segIdx, boolean passive)` Sets whether or not the segment indexed by `segIdx` is passive, meaning that its length is not included as part of the spring's active length.
`void`	`setSegmentWrappable(int numk)` Sets the current spring segment (the one following the most recently added point) to be wrappable, with a specified number of knots.
`void`	`setSegmentWrappable(int segIdx, int numk, Point3d[] initialPnts)` Sets the segment indexed by `segIdx` to be wrappable, with a specified number of knots and set of initialization points.
`void`	`setSegmentWrappable(int numk, Point3d[] initialPnts)` Sets the current spring segment (the one following the most recently added point) to be wrappable, with a specified number of knots and initialization points.
`void`	`setSor(double sor)` Sets the successive overrelaxation parameter for this spring.
`void`	`setState(DataBuffer data)` Restores the state for this component by reading from the supplied data buffer, starting at the current buffer offsets.
`void`	`setWrapDamping(double damping)` Sets the wrap damping for this spring.
`void`	`setWrapKnotDensity(double p)` Sets the default knot density for wrapping strands.
`void`	`setWrapKnotDensityMode(PropertyMode mode)`
`void`	`setWrapStiffness(double stiffness)` Sets the wrap stiffness for this spring.
`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.
`void`	`updateReferences(boolean undo, java.util.Deque<java.lang.Object> undoInfo)` May be called by the system if any of the soft references for this component are removed from the the component hierarchy.
`void`	`updateSlavePos()` Called when the system's dynamic position state changes, to update the position state of the slave objects.
`void`	`updateSlaveVel()` Called when the system's dynamic velocity state changes, to update the velocity state of the slave objects.
`void`	`updateStructure()` Hook method to allow sub-classes to update their structure by adding or removing points.
`void`	`updateWrapSegments()`
`void`	`updateWrapSegments(int maxIter)` Updates the wrap path for all wrappable segments in this spring, using a secified maximum number of iterations.

Methods inherited from class artisynth.core.mechmodels.PointSpringBase
advanceState, computeDFdl, computeDFdl, computeDFdldot, computeDFdldot, computeF, computeF, createDefaultMaterial, createRenderProps, getAuxVarDerivative, getAuxVarState, getEffectiveMaterial, getForceScaling, getMaterial, getMaxForce, getRenderColor, getRenderHints, getRenderProps, getRestLength, getSelection, getStateVersion, isSelectable, normalizeForceScaling, numAuxVars, numSelectionQueriesNeeded, requiresAdvance, setAuxVarState, setDamping, setLinearMaterial, setMaterial, setMaxForce, setRenderProps, setRestLength, setStiffness

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

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

Methods inherited from interface artisynth.core.modelbase.TransformableGeometry
transformPriority

Methods inherited from interface artisynth.core.modelbase.ModelComponent
connectToHierarchy, disconnectFromHierarchy, getName, getNavpanelVisibility, getNumber, getParent, isFixed, isMarked, isSelected, notifyParentOfChange, setFixed, setMarked, setName, setNumber, setParent, setSelected, setWritable

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
  - myDrawWrapPoints
```
public static boolean myDrawWrapPoints
```
  - totalStuck
```
public int totalStuck
```
  - totalCalls
```
public int totalCalls
```
  - totalFails
```
public int totalFails
```
  - totalFalseStuck
```
public int totalFalseStuck
```
  - maxForceNorm
```
public double maxForceNorm
```
  - sumForceNorm
```
public double sumForceNorm
```
  - maxLengthErr
```
public double maxLengthErr
```
  - sumLengthErr
```
public double sumLengthErr
```
  - myProps
```
public static PropertyList myProps
```
- Constructor Detail
  - MultiPointSpring
```
public MultiPointSpring()
```
    Constructs an empty multipoint spring.
  - MultiPointSpring
```
public MultiPointSpring(java.lang.String name)
```
    Constructs an empty multipoint spring with a name.
    
    Parameters:
    
    name - name for the spring
  - MultiPointSpring
```
public MultiPointSpring(java.lang.String name,
                        double k,
                        double d,
                        double l0)
```
    Constructs an empty multipoint spring with a name and initialized with a linear axial material.
    
    Parameters:
    
    name - name for the spring
    
    k - stiffness for the axial material
    
    d - damping for the axial material
    
    l0 - rest length for the axial material
  - MultiPointSpring
```
public MultiPointSpring(double k,
                        double d,
                        double l0)
```
    Constructs an empty multipoint spring initialized with a linear axial material.
    
    Parameters:
    
    k - stiffness for the axial material
    
    d - damping for the axial material
    
    l0 - rest length for the axial material
- Method Detail
  - getAllPropertyInfo
```
public PropertyList getAllPropertyInfo()
```
    Returns a list giving static information about all properties exported by this object.
    
    Specified by:
    
    getAllPropertyInfo in interface HasProperties
    
    Overrides:
    
    getAllPropertyInfo in class PointSpringBase
    
    Returns:
    
    static information for all exported properties
  - getWrapStiffness
```
public double getWrapStiffness()
```
    Queries the wrap stiffness for this spring.
    
    Returns:
    
    wrap stiffness
  - setWrapStiffness
```
public void setWrapStiffness(double stiffness)
```
    Sets the wrap stiffness for this spring. There is usually no need to set this, since without loss of generality, the wrap stiffness can be set to 1.
    
    Parameters:
    
    stiffness - wrap stiffness
  - getWrapDamping
```
public double getWrapDamping()
```
    Queries the wrap damping for this spring.
    
    Returns:
    
    wrap damping
  - setWrapDamping
```
public void setWrapDamping(double damping)
```
    Sets the wrap damping for this spring. If the wrap damping is K, then values between 10 K and 100 K generally give good results.
    
    Parameters:
    
    damping - wrap damping
  - getContactStiffness
```
public double getContactStiffness()
```
    Queries the contact stiffness for this spring.
    
    Returns:
    
    contact stiffness
  - setContactStiffness
```
public void setContactStiffness(double stiffness)
```
    Sets the contact stiffness for this spring. If K is the wrap damping, then a value of 10 K generally gives good results.
    
    Parameters:
    
    stiffness - contact stiffness
  - getContactDamping
```
public double getContactDamping()
```
    Queries the the contact damping for this spring.
    
    Returns:
    
    contact damping
  - setContactDamping
```
public void setContactDamping(double damping)
```
    Sets the contact damping for this spring. By default, the contact damping is 0.
    
    Parameters:
    
    damping - contact damping
  - setWrapKnotDensity
```
public void setWrapKnotDensity(double p)
```
    Sets the default knot density for wrapping strands. This is the number of knots used per unit distance. When a wrapping strand is initialized, and the number of knots is not explicitly specified, this number is multiplied by the strand's initial length to determine the number of knots.
    
    Parameters:
    
    p - desired knot density
  - getWrapKnotDensity
```
public double getWrapKnotDensity()
```
    Returns the default knot density for wrapping strands. See setWrapKnotDensity(double) for details.
    
    Returns:
    
    current knot density
  - getWrapKnotDensityMode
```
public PropertyMode getWrapKnotDensityMode()
```
  - setWrapKnotDensityMode
```
public void setWrapKnotDensityMode(PropertyMode mode)
```
  - getMaxWrapIterations
```
public int getMaxWrapIterations()
```
    Queries the maximum number of wrap iterations for this spring.
    
    Returns:
    
    maximum number of wrap iterations
  - setMaxWrapIterations
```
public void setMaxWrapIterations(int num)
```
    Sets the maximum number of wrap iterations for this spring.
    
    Parameters:
    
    num - maximum number of wrap iterations
  - getMaxWrapDisplacement
```
public double getMaxWrapDisplacement()
```
    Queries the maximum wrap displacement for this spring.
    
    Returns:
    
    maximum wrap displacement
  - setMaxWrapDisplacement
```
public void setMaxWrapDisplacement(double d)
```
    Sets the maximum wrap displacement for this spring. Setting a value of -1 causes the displacement to be computed automatically.
    
    Parameters:
    
    d - maximum wrap displacement
  - getConvergenceTol
```
public double getConvergenceTol()
```
    Queries the convergence tolerance for this spring. See setConvergenceTol(double) for a description of the tolerance.
    
    Returns:
    
    convergence tolerance
  - setConvergenceTol
```
public void setConvergenceTol(double tol)
```
    Sets the convergence tolerance tol for this spring. The default value is 1.0e-5. The tolerance specifies the maximum residual force at each knot as a fraction of the nominal wrapping tension F.
    Since F is given by
```
     K l
 F = ---
      m
 
```
    where K is the wrap stiffness, l is the strand length, and m is the number of knots, a maximum residual of F * tol at each knot implies a bound on the norm of the total force vector given by
```
            K l tol
 || f || <  -------
            sqrt(m)
 
```
    Parameters:
    
    tol - convergence tolerance
  - getLineSearch
```
public boolean getLineSearch()
```
    Queries whether line search is enabled for this spring.
    
    Returns:
    
    true if line search is enabled
  - setLineSearch
```
public void setLineSearch(boolean enable)
```
    Enables or disables line search for this spring. Line search is enabled by default.
    
    Parameters:
    
    enable - if true, enables line search
  - getDrawKnots
```
public boolean getDrawKnots()
```
    Queries whether knot rendering is enabled for this spring.
    
    Returns:
    
    true if knot rendering is enabled
  - setDrawKnots
```
public void setDrawKnots(boolean enable)
```
    Enables or disables knot rendering for this spring.
    
    Parameters:
    
    enable - if true, enables knot rendering
  - getDrawABPoints
```
public boolean getDrawABPoints()
```
    Queries whether drawing A/B points is enabled for this spring.
    
    Returns:
    
    true if drawing A/B points is enabled
  - setDrawABPoints
```
public void setDrawABPoints(boolean enable)
```
    Enables or disables drawing A/B points for this spring.
    
    Parameters:
    
    enable - if true, drawing A/B points is enabled
  - getABPointColor
```
public java.awt.Color getABPointColor()
```
    Queries the color to be used for rendering A/B points.
    
    Returns:
    
    A/B point color
  - setABPointColor
```
public void setABPointColor(java.awt.Color color)
```
    Sets the color to be used for rendering A/B points.
    
    Parameters:
    
    color - A/B point color
  - getContactingKnotsColor
```
public java.awt.Color getContactingKnotsColor()
```
    Queries the color, if any, used for rendering knots that are in contact, or null if no such color is specified.
    
    Returns:
    
    color for rendering contacting knots, or null
  - setContactingKnotsColor
```
public void setContactingKnotsColor(java.awt.Color color)
```
    Sets a special color that should be used for rendering knots that are in contact. Specifying null removes any special color.
    
    Parameters:
    
    color - color for rendering contacting knots, or null
  - getSor
```
public double getSor()
```
    Gets the successive overrelaxation parameter for this spring.
    
    Returns:
    
    successive overrelaxation parameter
  - setSor
```
public void setSor(double sor)
```
    Sets the successive overrelaxation parameter for this spring. The default value is 1, meaning that SOR is not currently used.
    
    Parameters:
    
    sor - successive overrelaxation parameter
  - getDebugLevel
```
public int getDebugLevel()
```
    Gets the debug level for this spring.
    
    Returns:
    
    debug level
  - setDebugLevel
```
public void setDebugLevel(int level)
```
    Sets the debug level for this spring. Values > 0 causes different amount of debugging information to be printed.
    
    Parameters:
    
    level - debug level
  - getProfiling
```
public boolean getProfiling()
```
    Queries whether the collection of profiling information is enabled for this spring.
    
    Returns:
    
    true if profiling is enabled
  - setProfiling
```
public void setProfiling(boolean enabled)
```
    Enables or disables the collection of profiling information for this spring. Profiling information includes computation time, and cummulative counts of iterations and contact detection.
    
    Parameters:
    
    enabled - if true, enabled profiling
  - getDrawDisplacements
```
public double getDrawDisplacements()
```
  - setDrawDisplacements
```
public void setDrawDisplacements(double scale)
```
  - getPrintProfiling
```
public boolean getPrintProfiling()
```
    Queries whether printing profile timing information is enabled for this spring.
    
    Returns:
    
    true if printing profile timing information is enabled
  - setPrintProfiling
```
public void setPrintProfiling(boolean enabled)
```
    Enables or disables the printing of profile timing information for this spring.
    
    Parameters:
    
    enabled - if true, printing profile timing information is enabled
  - getProfileTimeUsec
```
public double getProfileTimeUsec()
```
    When profiling is enabled, returns the averge compute time required to update each wrap path.
    
    Returns:
    
    average wrap path compute time (in usec)
  - getUpdateContactsCount
```
public int getUpdateContactsCount()
```
    When profiling is enabled, returns the cummulative number of contact detection operations for all wrappable segment updates.
    
    Returns:
    
    cummulative number of contact detection operations
  - getIterationCount
```
public int getIterationCount()
```
    When profiling is enabled, returns the cummulative number of iterations for updating all wrap paths.
    
    Returns:
    
    cummulative number of wrap path iterations
  - getConvergedCount
```
public int getConvergedCount()
```
    When profiling is enabled, returns the total number of times that the wrap path solution converged.
    
    Returns:
    
    total number of times the path solution converged
  - getContactCount
```
public int getContactCount()
```
    When profiling is enabled, returns the total number of times that the wrap path was in contact.
    
    Returns:
    
    total number of times the wrap path was in contact
  - getProfileCount
```
public int getProfileCount()
```
    When profiling is enabled, returns the total number of times a wrap path has been updated.
    
    Returns:
    
    total number of wrap path updates
  - addPoint
```
public void addPoint(int idx,
                     Point pnt)
```
    Adds a point to this spring at a specified index. This will also add a segment to the spring. The index value idx must not exceed the current number of points.
    
    Parameters:
    
    idx - index location for the point
    
    pnt - point to add
  - addPoint
```
public void addPoint(Point pnt)
```
    Adds a point to this spring. The will also begin the definition of a new segment.
    
    Parameters:
    
    pnt - point to add
  - getPoint
```
public Point getPoint(int idx)
```
    Returns the idx-th point in this spring.
    
    Parameters:
    
    idx - point index
    
    Returns:
    
    the idx-th point
  - numPoints
```
public int numPoints()
```
    Queries the number of points in this spring.
    
    Returns:
    
    number of points in the spring
  - indexOfPoint
```
public int indexOfPoint(Point pnt)
```
    Returns the index of a specified point in this spring, or -1 if the point is not present.
    
    Parameters:
    
    pnt - point whose index is desired
    
    Returns:
    
    index of the point, or -1 if not present
  - containsPoint
```
public boolean containsPoint(Point pnt)
```
    Queries whether this spring contains a specified points.
    
    Returns:
    
    true if the spring contains the point
  - removePoint
```
public boolean removePoint(Point pnt)
```
    Removes a point (and the corresponding segment, if the point is not the first point) from this spring.
    
    Parameters:
    
    pnt - point to remove
    
    Returns:
    
    true if the point was present in the spring and removed
  - clearPoints
```
public void clearPoints()
```
    Removes all points (and segments) from this spring.
  - addWrappable
```
public void addWrappable(Wrappable wrappable)
```
    Adds a wrappable to this spring which is applied to all wrap segments.
    
    Parameters:
    
    wrappable - wrappable to add
  - addWrappable
```
public void addWrappable(Wrappable wrappable,
                         int pntIdx0,
                         int pntIdx1)
```
    Adds a wrappable to this spring which is applied to the segments between the points indexed by pntIdx0 and pntIdx1. pntIdx0 and pntIdx1 are assumed to be non-negative with pntIdx0 <= pntIdx1; otherwise, the wrappable will be applied to all segments.
    The range indicated by pntIdx0 and pntIdx1 may lie partly or completely outside the range of actual points. The range will also remain fixed even if points are subseqently added or removed from the spring.
    
    Parameters:
    
    wrappable - wrappable to add
    
    pntIdx0 - index of the first point in the wrapping range
    
    pntIdx1 - index of the second point in the wrapping range
  - containsWrappable
```
public boolean containsWrappable(Wrappable wrappable)
```
    Queries whether or not this spring contains a wrappable for which wrapping is applied to all segments.
    
    Parameters:
    
    wrappable - wrappable to query
    
    Returns:
    
    true if the wrappable is present in the spring
  - containsWrappable
```
public boolean containsWrappable(Wrappable wrappable,
                                 int pntIdx0,
                                 int pntIdx1)
```
    Queries whether or not this spring contains a wrappable which is applied to the segments between the points indexed by pntIdx0 and pntIdx1. See addWrappable(Wrappable,int,int) for a description of the constraints on pntIdx0 and pntIdx1.
    
    Parameters:
    
    wrappable - wrappable to query
    
    pntIdx0 - index of the first point in the wrapping range
    
    pntIdx1 - index of the second point in the wrapping range
    
    Returns:
    
    true if the wrappable is present in the spring
  - numWrappables
```
public int numWrappables()
```
    Queries the number of wrappables specified in this spring. Note that the same wrappable may be specified multiple times if it has different segment ranges.
    
    Returns:
    
    number of wrappables in this spring
  - indexOfWrappable
```
public int indexOfWrappable(Wrappable wrappable)
```
    Returns the index of a wrappable in this spring which is applied to all segments, or -1 if such a wrappable is not present.
    
    Parameters:
    
    wrappable - wrappable to locate
    
    Returns:
    
    index of the wrappable, or -1 if not present
  - indexOfWrappable
```
public int indexOfWrappable(Wrappable wrappable,
                            int pntIdx0,
                            int pntIdx1)
```
    Returns the index of a wrappable in this spring which is applied to the segments between the points indexed by pntIdx0 and pntIdx1. See addWrappable(Wrappable,int,int) for a description of the constraints on pntIdx0 and pntIdx1. If no such wrappable is present, the method returns -1.
    
    Parameters:
    
    wrappable - wrappable to locate
    
    pntIdx0 - index of the first point in the wrapping range
    
    pntIdx1 - index of the second point in the wrapping range
    
    Returns:
    
    index of the wrappable, or -1 if not present
  - getWrappable
```
public Wrappable getWrappable(int idx)
```
    Returns the idx-th wrappable in this spring.
    
    Parameters:
    
    idx - index of the wrappable
    
    Returns:
    
    idx-th wrappable in this spring
  - getWrappableRange
```
public int[] getWrappableRange(int idx)
```
    Returns the point indices defining the wrappable range for the idx-th wrappable in this spring. Values of -1 indicate that the wrappable is applied to all segments.
    
    Parameters:
    
    idx - index of the wrappable
    
    Returns:
    
    point indices defining the wrappable range.
  - removeWrappable
```
public boolean removeWrappable(Wrappable wrappable)
```
    Remove from this spring a wrappable which is applied to all segments.
    
    Parameters:
    
    wrappable - wrappable to remove
    
    Returns:
    
    true if the wrappable was present
  - removeWrappable
```
public boolean removeWrappable(Wrappable wrappable,
                               int pntIdx0,
                               int pntIdx1)
```
    Remove from this spring a wrappable which is applied to the segments between the points indexed by pntIdx0 and pntIdx1. See addWrappable(Wrappable,int,int) for a description of the constraints on pntIdx0 and pntIdx1.
    
    Parameters:
    
    wrappable - wrappable to remove
    
    pntIdx0 - index of the first point in the wrapping range
    
    pntIdx1 - index of the second point in the wrapping range
    
    Returns:
    
    true if the wrappable was present
  - clearWrappables
```
public void clearWrappables()
```
    Removes all wrappables from this spring
  - getSegmentSpec
```
public MultiPointSpring.SegmentSpec getSegmentSpec(int segIdx)
```
    Returns the segment indexed by segIdx in this spring. This is the segment that lies between points idx and idx+1.
    
    Parameters:
    
    segIdx - index of the segment
    
    Returns:
    
    the idx-th segment
  - getSegment
```
public MultiPointSpring.Segment getSegment(int segIdx)
```
    Returns the curren segment indexed by segIdx in this spring.
    
    Parameters:
    
    segIdx - index of the segment
    
    Returns:
    
    the idx-th segment
  - setSegmentWrappable
```
public void setSegmentWrappable(int numk)
```
    Sets the current spring segment (the one following the most recently added point) to be wrappable, with a specified number of knots. The initial path for the segment is taken to be a straight line between its end points.
    
    Parameters:
    
    numk - number of knots to be used in the segment
  - setSegmentWrappable
```
public void setSegmentWrappable(int numk,
                                Point3d[] initialPnts)
```
    Sets the current spring segment (the one following the most recently added point) to be wrappable, with a specified number of knots and initialization points.
    The initialization points are described by initialPnts and are used to specify the wrap path for the segment: the knots are distributed along the piecewise-linear path defined by the segment end points on each end and the initialization points in between. The path is then ``pulled taught'' while wrapping around any intermediate obstacles.
    
    Parameters:
    
    numk - number of knots to be used in the segment
    
    initialPnts - initialization points
  - setSegmentWrappable
```
public void setSegmentWrappable(int segIdx,
                                int numk,
                                Point3d[] initialPnts)
```
    Sets the segment indexed by segIdx to be wrappable, with a specified number of knots and set of initialization points. See setSegmentWrappable(int,Point3d[]) for a description of how the initialization points are used.
    
    Parameters:
    
    segIdx - index of the segment
    
    numk - number of knots to be used in the segment
    
    initialPnts - initialization points
  - setAllSegmentsWrappable
```
public void setAllSegmentsWrappable(int numk)
```
    Sets all segments in this spring to be wrappable with a specified number of knots. The initial path for each segment is taken to be a straight line between its end points.
    
    Parameters:
    
    numk - number of knots to be used in each segment
  - clearWrappableSegment
```
public boolean clearWrappableSegment(int segIdx)
```
  - initializeSegment
```
public void initializeSegment(int segIdx,
                              Point3d[] initialPnts)
```
    Initializes the wrap path for the wrappable segment indexed by segIdx, using a specified set of initialization points. See setSegmentWrappable(int,Point3d[]) for a description of how the initialization points are used.
    
    Parameters:
    
    segIdx - index of the segment
    
    initialPnts - initialization points
  - numSegmentSpecs
```
public int numSegmentSpecs()
```
    Returns the number of specified segment in this spring.
    
    Returns:
    
    number of specified segments
  - numSegments
```
public int numSegments()
```
    Returns the current number of segments in this spring. For internal use only.
    
    Returns:
    
    current number of segments
  - isSegmentPassive
```
public boolean isSegmentPassive(int segIdx)
```
    Queries whether the segment indexed by segIdx is passive.
    
    Returns:
    
    true if the segment is passive
  - setSegmentPassive
```
public void setSegmentPassive()
```
    Sets the current spring segment (the one following the most recently added point) to be passive, meaning that its length is not included as part of the spring's active length.
  - setSegmentPassive
```
public void setSegmentPassive(int segIdx,
                              boolean passive)
```
    Sets whether or not the segment indexed by segIdx is passive, meaning that its length is not included as part of the spring's active length.
    
    Parameters:
    
    segIdx - index of the segment
    
    passive - if true, makes the segment passive
  - numPassiveSegments
```
public int numPassiveSegments()
```
    Queries the number of passive segments in this spring.
    
    Returns:
    
    number of passive segments
  - numKnots
```
public int numKnots(int segIdx)
```
    Queries the number of knots in the current segment indexed by segIdx. Returns 0 if the segment is not wrappable.
    
    Parameters:
    
    segIdx - index of the current segment
    
    Returns:
    
    number of knots in the segment
  - getKnot
```
public MultiPointSpring.WrapKnot getKnot(int segIdx,
                                         int k)
```
    Returns the k-th knot in the current segment indexed by segIdx.
    
    Parameters:
    
    segIdx - index of the current segment
    
    k - index of the knot within the segment
    
    Returns:
    
    k-th knot in segment
  - updateWrapSegments
```
public void updateWrapSegments(int maxIter)
```
    Updates the wrap path for all wrappable segments in this spring, using a secified maximum number of iterations.
    
    Parameters:
    
    maxIter - maximum number of iterations
  - hasWrappableSegments
```
public boolean hasWrappableSegments()
```
  - hasConditionalPoints
```
public boolean hasConditionalPoints()
```
  - hasMovingMarkers
```
public boolean hasMovingMarkers()
```
  - updateBounds
```
public void updateBounds(Vector3d pmin,
                         Vector3d pmax)
```
    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
    
    Specified by:
    
    updateBounds in class PointSpringBase
    
    Parameters:
    
    pmin - minimum point
    
    pmax - maximum point
  - prerender
```
public 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). 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
    
    Overrides:
    
    prerender in class PointSpringBase
    
    Parameters:
    
    list - list of objects to be rendered
  - render
```
public void render(Renderer renderer,
                   int flags)
```
    Render this object using the functionality of the supplied Renderer.
    
    Specified by:
    
    render in interface IsRenderable
    
    Specified by:
    
    render in class PointSpringBase
    
    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.
  - scan
```
public void scan(ReaderTokenizer rtok,
                 java.lang.Object ref)
          throws java.io.IOException
```
    Scans this element from a ReaderTokenizer. The expected text format is assumed to be compatible with that produced by write.
    
    Specified by:
    
    scan in interface ModelComponent
    
    Specified by:
    
    scan in interface Scannable
    
    Overrides:
    
    scan in class ModelComponentBase
    
    Parameters:
    
    rtok - Tokenizer from which to scan the element
    
    ref - optional reference object which can be used for resolving references to other objects
    
    Throws:
    
    java.io.IOException - if an I/O or formatting error occured
  - postscan
```
public void postscan(java.util.Deque<ScanToken> tokens,
                     CompositeComponent ancestor)
              throws java.io.IOException
```
    Performs any required post-scanning for this component. This involves handling any information whose processing was deferred during the scan() method and stored in the token queue. The most common use of this method is to resolve the paths of component references, which may not have been created at the time of the initial scan() call.
    
    Specified by:
    
    postscan in interface PostScannable
    
    Overrides:
    
    postscan in class ModelComponentBase
    
    Parameters:
    
    tokens - token information that was stored during scan().
    
    ancestor - ancestor component with respect to which reference component paths are defined.
    
    Throws:
    
    java.io.IOException - if an error is encountered (such as a reference to a non-existent component)
  - scaleDistance
```
public void scaleDistance(double s)
```
    Scales all distance coordinates.
    
    Specified by:
    
    scaleDistance in interface ScalableUnits
    
    Overrides:
    
    scaleDistance in class PointSpringBase
    
    Parameters:
    
    s - scaling factor
  - scaleMass
```
public void scaleMass(double s)
```
    Scales all mass units.
    
    Specified by:
    
    scaleMass in interface ScalableUnits
    
    Overrides:
    
    scaleMass in class PointSpringBase
    
    Parameters:
    
    s - scaling factor
  - transformGeometry
```
public void transformGeometry(AffineTransform3dBase X)
```
    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
  - transformGeometry
```
public void transformGeometry(GeometryTransformer gtr,
                              TransformGeometryContext context,
                              int flags)
```
    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
  - addTransformableDependencies
```
public void addTransformableDependencies(TransformGeometryContext context,
                                         int flags)
```
    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
  - isDuplicatable
```
public boolean isDuplicatable()
```
    Returns false, since copying of MultiPointSpring is not currently implemented.
    
    Specified by:
    
    isDuplicatable in interface CopyableComponent
    
    Returns:
    
    true if this component can be duplicated.
  - getCopyReferences
```
public boolean getCopyReferences(java.util.List<ModelComponent> refs,
                                 ModelComponent ancestor)
```
    Does nothing and returns false, since copying of MultiPointSpring is not currently implemented.
    
    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)
```
    Makes a copy of this spring. Not currently implemented.
    
    Specified by:
    
    copy in interface CopyableComponent
    
    Overrides:
    
    copy in class PointSpringBase
    
    Parameters:
    
    flags - flags to control the copying
    
    copyMap - map to possible existing instances of referenced components
    
    Returns:
    
    copy of this component
  - getHardReferences
```
public void getHardReferences(java.util.List<ModelComponent> refs)
```
    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. Hard references for MultiPointSpring include the two end points.
    
    Specified by:
    
    getHardReferences in interface ModelComponent
    
    Overrides:
    
    getHardReferences in class ModelComponentBase
    
    Parameters:
    
    refs - list to which hard references are appended
  - getSoftReferences
```
public void getSoftReferences(java.util.List<ModelComponent> refs)
```
    Appends all soft 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 ExcitationComponent may refer to one or more other ExcitationComponents to act as excitation sources. A soft reference is one which can be removed from the referring component. In particular, if any soft references for a component are deleted, then that component's updateReferences() method will be called to update its internal reference information. Soft references for MultiPointSpring include intermediate points between the two end points, and the wrappables.
    
    Specified by:
    
    getSoftReferences in interface ModelComponent
    
    Overrides:
    
    getSoftReferences in class ModelComponentBase
    
    Parameters:
    
    refs - list to which soft references are appended
  - updateReferences
```
public void updateReferences(boolean undo,
                             java.util.Deque<java.lang.Object> undoInfo)
```
    May be called by the system if any of the soft references for this component are removed from the the component hierarchy. If called with undo equal to false, this component should then examine its soft references and use ComponentUtils.areConnected() to determine which of them have been disconnected from the hierarchy. Disconnected references should be removed, and sufficient information should be appended to undoInfo to allow this update to be undone if this method is called later with undo equal to true. When undoing an update, the undo information should be removed from the front of undoInfo.
    
    Specified by:
    
    updateReferences in interface ModelComponent
    
    Overrides:
    
    updateReferences in class ModelComponentBase
    
    Parameters:
    
    undo - if true, indicates that the most recent reference update should be undone, using the supplied undo information.
    
    undoInfo - if undo is false, should be used to store information allowing the reference update to be undone. Otherwise, if undo is true, then this supplied information to undo the most recent update.
  - setRestLengthFromPoints
```
public double setRestLengthFromPoints()
```
    Sets the rest length of the spring from the current point locations
    
    Specified by:
    
    setRestLengthFromPoints in class PointSpringBase
    
    Returns:
    
    the new rest length
  - getActiveLengthDot
```
public double getActiveLengthDot()
```
    Computes the derivative of the active length of this spring. The active length is the length of all the active segments.
    
    Returns:
    
    active length derivative
  - getLengthDot
```
public double getLengthDot()
```
    Computes the derivative of the length of this spring.
    
    Specified by:
    
    getLengthDot in class PointSpringBase
    
    Returns:
    
    length derivative
  - getActiveLength
```
public double getActiveLength()
```
    Computes the active length of this spring, corresponding to the length of all the active segments.
    
    Returns:
    
    active length of this spring
  - getLength
```
public double getLength()
```
    Computes the length of this spring.
    
    Specified by:
    
    getLength in class PointSpringBase
    
    Returns:
    
    length of this spring
  - preadvance
```
public void preadvance(double t0,
                       double t1,
                       int flags)
```
    Called from within the model's {advance() method, before position and velocity states are advanced.
    For MultiPointSpring, this method updates the spring's structure and wrap segments when t0 is 0. Otherwise, the method does nothing.
    
    Specified by:
    
    preadvance in interface RequiresPrePostAdvance
    
    Parameters:
    
    t0 - current time (seconds)
    
    t1 - new time to be advanced to (seconds)
    
    flags - flags passed to the model's preadvance() method (reserved for future use).
  - postadvance
```
public void postadvance(double t0,
                        double t1,
                        int flags)
```
    Called from within the model's advance() method, after all position and velocity state has been advanced.
    For MultiPointSpring, this method updates the spring's structure and wrap segments.
    
    Specified by:
    
    postadvance in interface RequiresPrePostAdvance
    
    Parameters:
    
    t0 - current time (seconds)
    
    t1 - new time to be advanced to (seconds)
    
    flags - flags passed to the model's advance() method (reserved for future use).
  - pathWrapString
```
public java.lang.String pathWrapString()
```
  - updateStructure
```
public void updateStructure()
```
    Hook method to allow sub-classes to update their structure by adding or removing points.
  - updateSlavePos
```
public void updateSlavePos()
```
    Called when the system's dynamic position state changes, to update the position state of the slave objects.
    
    Specified by:
    
    updateSlavePos in interface HasSlaveObjects
  - updateSlaveVel
```
public void updateSlaveVel()
```
    Called when the system's dynamic velocity state changes, to update the velocity state of the slave objects.
    
    Specified by:
    
    updateSlaveVel in interface HasSlaveObjects
  - hasState
```
public boolean hasState()
```
    Description copied from class: PointSpringBase
    
    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 PointSpringBase
    
    Returns:
    
    true if this component has state
  - 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
    
    Overrides:
    
    getState in class PointSpringBase
    
    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
    
    Overrides:
    
    setState in class PointSpringBase
    
    Parameters:
    
    data - buffer containing the state information
  - setKnotPositions
```
public void setKnotPositions(int segIdx,
                             Point3d[] plist)
```
    Sets the knot positions for a wrappable current segment indxed by segIdx. Used for debugging and testing.
    
    Parameters:
    
    segIdx - index of the current segment
    
    plist - array of knot positions
  - updateWrapSegments
```
public void updateWrapSegments()
```
  - getAllABPoints
```
public int getAllABPoints(java.util.ArrayList<Point> pnts)
```
    Returns all the AB points which are currently active on the segments. This should be called in sync with the simulation, since the set of AB points varies across time steps.
    
    Parameters:
    
    pnts - returns the AB points. Will be cleared at the start of the method.
    
    Returns:
    
    number of AB points found
  - applyForces
```
public void applyForces(double t)
```
    Applies forces to the points of this spring, as well as any wrappables that are in contact with wrappable segments, resulting from the tension in the spring.
    
    Specified by:
    
    applyForces in interface ForceEffector
    
    Specified by:
    
    applyForces in class Spring
    
    Parameters:
    
    t - time (seconds)
  - addSolveBlocks
```
public void addSolveBlocks(SparseNumberedBlockMatrix M)
```
    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
  - addPosJacobian
```
public 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.
    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
  - addVelJacobian
```
public 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.
    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
  - getJacobianType
```
public 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. 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
  - main
```
public static void main(java.lang.String[] args)
```

Class MultiPointSpring

Nested Class Summary

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

Field Summary

Fields inherited from class artisynth.core.mechmodels.PointSpringBase

Fields inherited from class artisynth.core.modelbase.ModelComponentBase

Fields inherited from interface artisynth.core.modelbase.TransformableGeometry

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.mechmodels.PointSpringBase

Methods inherited from class artisynth.core.modelbase.ModelComponentBase

Methods inherited from class java.lang.Object

Methods inherited from interface artisynth.core.modelbase.TransformableGeometry

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

myDrawWrapPoints

totalStuck

totalCalls

totalFails

totalFalseStuck

maxForceNorm

sumForceNorm

maxLengthErr

sumLengthErr

myProps

Constructor Detail

MultiPointSpring

MultiPointSpring

MultiPointSpring

MultiPointSpring

Method Detail

getAllPropertyInfo

getWrapStiffness

setWrapStiffness

getWrapDamping

setWrapDamping

getContactStiffness

setContactStiffness

getContactDamping

setContactDamping

setWrapKnotDensity

getWrapKnotDensity

getWrapKnotDensityMode

setWrapKnotDensityMode

getMaxWrapIterations

setMaxWrapIterations

getMaxWrapDisplacement

setMaxWrapDisplacement

getConvergenceTol

setConvergenceTol

getLineSearch

setLineSearch

getDrawKnots

setDrawKnots

getDrawABPoints

setDrawABPoints

getABPointColor

setABPointColor

getContactingKnotsColor

setContactingKnotsColor

getSor

setSor

getDebugLevel

setDebugLevel

getProfiling

setProfiling

getDrawDisplacements

setDrawDisplacements

getPrintProfiling

setPrintProfiling

getProfileTimeUsec

getUpdateContactsCount

getIterationCount

getConvergedCount

getContactCount