MechSystemBase (Artisynth API documentation)

java.lang.Object
- artisynth.core.modelbase.ModelComponentBase
- - artisynth.core.modelbase.ComponentList<ModelComponent>
  - - artisynth.core.modelbase.ModelBase
    - - artisynth.core.modelbase.RenderableModelBase
      - artisynth.core.mechmodels.MechSystemBase

All Implemented Interfaces:

MechSystem, MechSystemModel, ComponentChangeListener, ComponentListView<ModelComponent>, CompositeComponent, HasMenuItems, HasState, IndexedComponentList, Model, ModelComponent, MutableCompositeComponent<ModelComponent>, PostScannable, RenderableComponent, java.awt.event.ActionListener, java.lang.Cloneable, java.lang.Iterable<ModelComponent>, java.util.Collection<ModelComponent>, java.util.EventListener, HasProperties, HierarchyNode, HasRenderProps, IsRenderable, IsSelectable, Renderable, Disposable, ListView<ModelComponent>, ParameterizedClass, Scannable

Direct Known Subclasses:

FemModel, MechModel
```
public abstract class MechSystemBase
extends RenderableModelBase
implements MechSystemModel
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class MechSystemBase.ConstraintForceStateSaver
Special class to save/restore constraint forces as state
- Nested classes/interfaces inherited from interface artisynth.core.modelbase.ModelComponent
  ModelComponent.FilePathSaveType, ModelComponent.NavpanelVisibility
- Nested classes/interfaces inherited from interface artisynth.core.mechmodels.MechSystem
  MechSystem.ConstraintInfo
- Nested classes/interfaces inherited from interface artisynth.core.modelbase.CompositeComponent
  CompositeComponent.NavpanelDisplay

Nested Classes
Modifier and Type	Class and Description
`class`	`MechSystemBase.ConstraintForceStateSaver` Special class to save/restore constraint forces as state

Field Summary

Fields
Modifier and Type	Field and Description
`static MechSystemSolver.PosStabilization`	`DEFAULT_STABILIZATION`
`static boolean`	`DEFAULT_USE_IMPLICIT_FRICTION`
`static boolean`	`myParametricsInSystemMatrix`
`static PropertyList`	`myProps`
`static boolean`	`mySaveForcesAsState`
`static boolean`	`useAllDynamicComps`

Fields inherited from class artisynth.core.modelbase.ModelBase
DEFAULT_MAX_STEP_SIZE

Fields inherited from class artisynth.core.modelbase.ComponentList
DEFAULT_NAVPANEL_DISPLAY

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

Fields inherited from interface artisynth.core.modelbase.Model
STATE_IS_VOLATILE

Fields inherited from interface artisynth.core.mechmodels.MechSystem
COMPUTE_CONTACTS, UPDATE_CONTACTS

Fields inherited from interface maspack.render.IsRenderable
TRANSPARENT, TWO_DIMENSIONAL

Constructor Summary

Constructors
Constructor and Description

MechSystemBase(java.lang.String name)

Constructors
Constructor and Description
`MechSystemBase(java.lang.String name)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addActivePosImpulse(VectorNd x, double h, VectorNd v)` Computes an adjustment to the active positions of the system (stored in the vector `q`) by applying a velocity `u` for time `h`.
`void`	`addAttachmentJacobian(SparseNumberedBlockMatrix S, VectorNd f)`
`void`	`addAttachmentSolveBlocks(SparseNumberedBlockMatrix S)`
`void`	`addGeneralMassBlocks(SparseNumberedBlockMatrix M)`
`void`	`addGeneralSolveBlocks(SparseNumberedBlockMatrix M)`
`void`	`addPosJacobian(SparseNumberedBlockMatrix S, VectorNd f, double s)` Adds the current force-position Jacobian, scaled by `h`, to the matrix `S`, which should have been previously created with a call to `buildSolveMatrix()`.
`void`	`addVelJacobian(SparseNumberedBlockMatrix S, VectorNd f, double s)` Adds the current force-velocity Jacobian, scaled by `h`, to the matrix `S`, which should have been previously created with a call to `buildSolveMatrix()`.
`StepAdjustment`	`advance(double t0, double t1, int flags)` Advances this model from time t0 to time t1.
`void`	`advanceAuxState(double t0, double t1)`
`void`	`applyAttachmentForces()`
`boolean`	`buildMassMatrix(SparseNumberedBlockMatrix M)` Builds a mass matrix for this system.
`void`	`buildSolveMatrix(SparseNumberedBlockMatrix S)` Builds a solve matrix for this system.
`void`	`closePrintStateFile()`
`void`	`collectInitialForces()`
`MechSystemBase`	`copy(int flags, java.util.Map<ModelComponent,ModelComponent> copyMap)`
`ComponentState`	`createState(ComponentState prevState)` Factory routine to create a state object for this component, which can then be used as an argument for `HasState.setState(artisynth.core.modelbase.ComponentState)` and `HasState.getState(artisynth.core.modelbase.ComponentState)`.
`SparseBlockMatrix`	`createVelocityJacobian()`
`SparseBlockMatrix`	`getActiveDampingMatrix()`
`java.util.ArrayList<DynamicComponent>`	`getActiveDynamicComponents()` Returns a list of all the active dynamic components, which collectively determine the values returned by `getActiveForces(maspack.matrix.VectorNd)`, `getActivePosState(maspack.matrix.VectorNd)`, etc.
`void`	`getActiveForces(VectorNd f)` Returns the generalized forces acting on all the active components in this system.
`double`	`getActiveMass()`
`SparseBlockMatrix`	`getActiveMassMatrix()`
`void`	`getActivePosDerivative(VectorNd dxdt, double t)` Gets the current value of the position derivative for all active components.
`void`	`getActivePosState(VectorNd q)` Gets the current position state for all active components.
`int`	`getActivePosStateSize()` Returns the size of the position state for all active components.
`SparseBlockMatrix`	`getActiveStiffnessMatrix()`
`void`	`getActiveVelState(VectorNd u)` Gets the current velocity state for all active components.
`int`	`getActiveVelState(VectorNd u, int idx, boolean bodyCoords)`
`int`	`getActiveVelStateSize()` Returns the size of the velocity state for all active components.
`SparseBlockMatrix`	`getAttachmentConstraints()` Returns the transpose of the attachment constraint matrix.
`VectorNd`	`getAttachmentDerivatives()`
`void`	`getAuxAdvanceState(DataBuffer buf)`
`void`	`getAuxVarDerivative(VectorNd dwdt)`
`void`	`getAuxVarState(VectorNd w)`
`int`	`getAuxVarStateSize()`
`void`	`getBilateralConstraints(SparseBlockMatrix GT, VectorNd dg)` Obtains the transpose of the current bilateral constraint matrix G for this system.
`void`	`getBilateralConstraintSizes(VectorNi sizes)`
`void`	`getBilateralForces(VectorNd lam)` Returns from the system the most recently computed bilateral constraint forces.
`int`	`getBilateralForces(VectorNd lam, int idx)`
`void`	`getBilateralInfo(MechSystem.ConstraintInfo[] ginfo)` Obtains information for all the constraint directions returned by the most recent call to `getBilateralConstraints()`.
`static SparseSolverId`	`getDefaultMatrixSolver()`
`static MechSystemSolver.PosStabilization`	`getDefaultStabilization()`
`static boolean`	`getDefaultUseImplicitFriction()`
`java.util.ArrayList<DynamicComponent>`	`getDynamicComponents()` Returns a list of the dynamic components in this model.
`void`	`getDynamicDOFs(int[] dofs)` Returns in `sizes` the number of (velocity) degrees of freedom for the dynamic components in the system.
`boolean`	`getDynamicsEnabled()`
`java.util.ArrayList<ForceEffector>`	`getForceEffectors()` Returns a list of the force effectors in this model.
`void`	`getForces(VectorNd f)`
`int`	`getFrictionConstraints(SparseBlockMatrix DT, java.util.ArrayList<FrictionInfo> finfo, boolean prune)` Obtains the transpose of the current friction constraint matrix D for this system.
`void`	`getFrictionForces(VectorNd phi)` Returns from the system the most recently computed friction constraint forces.
`int`	`getFrictionForces(VectorNd phi, int idx)`
`void`	`getFrictionState(VectorNi state)`
`int`	`getFrictionState(VectorNi state, int idx)`
`void`	`getInitialState(ComponentState newstate, ComponentState oldstate)` Gets an initial state for this component and returns the value in `state`.
`MechSystemSolver.Integrator`	`getIntegrator()`
`void`	`getInverseMassMatrix(SparseBlockMatrix Minv, SparseBlockMatrix M)` Sets `Minv` to the inverse of the mass matrix `M`.
`void`	`getMassMatrix(SparseNumberedBlockMatrix M, VectorNd f, double t)` Sets `M` to the current value of the mass matrix for this system, evaluated at time `t`.
`SparseSolverId`	`getMatrixSolver()`
`Range`	`getMatrixSolverRange()`
`int`	`getNumBilateralForces()`
`int`	`getNumUnilateralForces()`
`void`	`getParametricForces(VectorNd f)` Gets the forces associated with parametric components.
`void`	`getParametricPosState(VectorNd q)` Gets the current position state for all parametric components.
`int`	`getParametricPosStateSize()` Returns the size of the position state for all parametric components.
`void`	`getParametricPosTarget(VectorNd q, double s, double h)` Obtains the desired target position for all parametric components at a particular time.
`void`	`getParametricVelState(VectorNd u)` Gets the current velocity state for all parametric components.
`int`	`getParametricVelStateSize()` Returns the size of the velocity state for all parametric components.
`void`	`getParametricVelTarget(VectorNd u, double s, double h)` Obtains the desired target velocity for all parametric components at a particular time.
`double`	`getPenetrationLimit()`
`java.lang.String`	`getPrintState()`
`boolean`	`getProfiling()`
`void`	`getSlaveObjectComponents(java.util.List<HasSlaveObjects> comps, int level)` Should be overridden in subclasses to return all the HasSlaveObjects components within this model.
`int`	`getSolveMatrixType()` Returns information about the solve matrix for this system.
`MechSystemSolver`	`getSolver()`
`MechSystemSolver.PosStabilization`	`getStabilization()`
`void`	`getState(ComponentState pstate)` Get the current state of this component.
`int`	`getStructureVersion()` Returns the current structure version of this system.
`void`	`getUnilateralConstraints(SparseBlockMatrix NT, VectorNd dn)` Obtains the transpose of the current unilateral constraint matrix N for this system.
`void`	`getUnilateralConstraintSizes(VectorNi sizes)`
`void`	`getUnilateralForces(VectorNd the)` Returns from the system the most recently computed unilateral constraint forces.
`int`	`getUnilateralForces(VectorNd the, int idx)`
`void`	`getUnilateralInfo(MechSystem.ConstraintInfo[] ninfo)` Obtains information for all the constraint directions returned by the most recent call to `getUnilateralConstraints()`.
`void`	`getUnilateralState(VectorNi state)`
`int`	`getUnilateralState(VectorNi state, int idx)`
`boolean`	`getUpdateForcesAtStepEnd()`
`PropertyMode`	`getUpdateForcesAtStepEndMode()`
`boolean`	`getUseImplicitFriction()`
`void`	`initialize(double t)` Causes this model to initialize itself at time t.
`boolean`	`isBilateralStructureConstant()` Queries whether or not the matrix structure of the bilateral constraints returned by this system is constant for a given structure version.
`int`	`maxFrictionConstraintSets()` Returns that maximum number of friction constraint set that may be added by the method `getFrictionConstraints()`.
`int`	`numActiveComponents()` Returns the current number of active components in this system.
`int`	`numAttachedComponents()`
`int`	`numParametricComponents()` Returns the current number of parametric components in this system.
`java.io.PrintWriter`	`openPrintStateFile(java.lang.String fileName)`
`static void`	`placeDynamicComponent(java.util.List<DynamicComponent> active, java.util.List<DynamicComponent> attached, java.util.List<DynamicComponent> parametric, DynamicComponent d)`
`StepAdjustment`	`preadvance(double t0, double t1, int flags)` Prepares this model for advance from time t0 to time t1.
`void`	`printActiveMass()`
`void`	`printActiveMass(java.lang.String fmtStr)`
`void`	`printActiveStiffness()`
`void`	`printActiveStiffness(java.lang.String fmtStr)`
`void`	`recursivelyFinalizeAdvance(StepAdjustment stepAdjust, double t0, double t1, int flags, int level)`
`void`	`recursivelyInitialize(double t, int level)`
`void`	`recursivelyPrepareAdvance(double t0, double t1, int flags, int level)`
`void`	`reduceVelocityJacobian(SparseBlockMatrix J)`
`java.io.PrintWriter`	`reopenPrintStateFile(java.lang.String fileName)`
`void`	`setActiveForces(VectorNd f)` Sets the generalized forces acting on all the active components in this system.
`void`	`setActivePosState(VectorNd q)` Sets the current position state for all active components.
`void`	`setActiveVelState(VectorNd u)` Sets the current velocity state for all active components.
`void`	`setAuxAdvanceState(DataBuffer buf)`
`void`	`setAuxVarState(VectorNd w)`
`void`	`setBilateralForces(VectorNd lam, double s)` Supplies to the system the most recently computed bilateral constraint forces.
`int`	`setBilateralForces(VectorNd lam, double s, int idx)`
`static void`	`setDefaultMatrixSolver(SparseSolverId solverType)`
`static void`	`setDefaultStabilization(MechSystemSolver.PosStabilization stablizer)`
`static void`	`setDefaultUseImplicitFriction(boolean enable)`
`void`	`setDynamicsEnabled(boolean enable)`
`void`	`setForces(VectorNd f)`
`void`	`setFrictionForces(VectorNd phi, double s)` Supplies to the system the most recently computed friction constraint forces.
`int`	`setFrictionForces(VectorNd phi, double s, int idx)`
`void`	`setFrictionState(VectorNi state)`
`int`	`setFrictionState(VectorNi state, int idx)`
`void`	`setIntegrator(MechSystemSolver.Integrator integrator)`
`void`	`setMatrixSolver(SparseSolverId method)`
`void`	`setParametricForces(VectorNd f)` Sets the forces associated with parametric components.
`void`	`setParametricPosState(VectorNd q)` Sets the current position state for all parametric components.
`void`	`setParametricVelState(VectorNd q)` Sets the current velocity state for all parametric components.
`void`	`setPenetrationLimit(double lim)`
`void`	`setPrintState(java.lang.String fmt)`
`void`	`setPrintState(java.lang.String fmt, double interval)`
`void`	`setProfiling(boolean enable)`
`void`	`setStabilization(MechSystemSolver.PosStabilization stablizer)`
`void`	`setState(ComponentState pstate)` Set the state of this component.
`void`	`setUnilateralForces(VectorNd the, double s)` Supplies to the system the most recently computed unilateral constraint forces.
`int`	`setUnilateralForces(VectorNd the, double s, int idx)`
`void`	`setUnilateralState(VectorNi state)`
`int`	`setUnilateralState(VectorNi state, int idx)`
`void`	`setUpdateForcesAtStepEnd(boolean enable)`
`void`	`setUpdateForcesAtStepEndMode(PropertyMode mode)`
`void`	`setUseImplicitFriction(boolean enable)`
`static MechSystem`	`topMechSystem(ModelComponent comp)` Returns the topmost MechSystem, if any, that is associated with a specific component.
`void`	`updateAttachmentPos()`
`void`	`updateAttachmentVel()`
`boolean`	`updateConstraints(double t, StepAdjustment stepAdjust, int flags)` Updates the constraints associated with this system to be consistent with the current position and indicated time.
`void`	`updateDynamicComponentLists()`
`void`	`updateForceComponentList()`
`void`	`updateForces(double t)` Updates all internal forces associated with this system to be consistent with the current position and velocity and the indicated time `t`.
`void`	`updatePosState()`
`void`	`updateVelState()`
`void`	`writeBilateralConstraintMatrix(java.lang.String fileName)`
`void`	`writeBilateralConstraintMatrix(java.lang.String fileName, Matrix.WriteFormat matfmt)`
`void`	`writeMassMatrix(java.lang.String fileName)`
`void`	`writeMassMatrix(java.lang.String fileName, Matrix.WriteFormat matfmt)`
`void`	`writePrintStateHeader(java.lang.String description)`
`void`	`writeStiffnessMatrix(java.lang.String fileName, double h)`
`void`	`writeStiffnessMatrix(java.lang.String fileName, double h, Matrix.WriteFormat matfmt)`

Methods inherited from class artisynth.core.modelbase.RenderableModelBase
createRenderProps, getAllPropertyInfo, getRenderHints, getRenderProps, getSelection, isSelectable, numSelectionQueriesNeeded, prerender, render, setRenderProps, updateBounds

Methods inherited from class artisynth.core.modelbase.ModelBase
actionPerformed, copy, dispose, getDefaultMaxStepSize, getMaxStepSize, getMenuItems, hasParameterizedType, hierarchyContainsReferences, setDefaultMaxStepSize, setMaxStepSize

Methods inherited from class artisynth.core.modelbase.ComponentList
add, add, addAll, addComponents, addFixed, addNumbered, clear, clone, componentChanged, contains, contains, containsAll, ensureCapacity, findComponent, get, get, getByNumber, getChildren, getMinNumber, getNavpanelDisplay, getNumberLimit, getOneBasedNumbering, getParameterType, getShortName, hasChildren, incrementNumbering, indexOf, invalidateNumbers, isEditable, isEmpty, iterator, nextComponentNumber, numComponents, postscan, remove, remove, removeAll, removeAll, removeComponents, resetNumbersToIndices, retainAll, scan, set, setEditable, setNavpanelDisplay, setNumbered, setOneBasedNumbering, setShortName, size, toArray, toArray, updateNameMap

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

Methods inherited from interface artisynth.core.mechmodels.MechSystemModel
checkVelocityStability, getAttachments, getAuxStateComponents, getCollidables, getConstrainers, getDynamicComponents, getDynamicComponents, getForceEffectors, getMassMatrixValues, mulInverseMass

Methods inherited from interface artisynth.core.modelbase.Model
dispose, getMaxStepSize

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

Methods inherited from interface maspack.properties.HasProperties
getAllPropertyInfo, getProperty

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

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

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

Methods inherited from interface artisynth.core.modelbase.ComponentListView
getName

Methods inherited from interface java.util.Collection
equals, hashCode, parallelStream, removeIf, spliterator, stream

Methods inherited from interface java.lang.Iterable
forEach

Methods inherited from interface artisynth.core.modelbase.CompositeComponent
recursivelyFind

- Field Detail
  - mySaveForcesAsState
```
public static boolean mySaveForcesAsState
```
  - myParametricsInSystemMatrix
```
public static boolean myParametricsInSystemMatrix
```
  - useAllDynamicComps
```
public static boolean useAllDynamicComps
```
  - DEFAULT_STABILIZATION
```
public static MechSystemSolver.PosStabilization DEFAULT_STABILIZATION
```
  - DEFAULT_USE_IMPLICIT_FRICTION
```
public static boolean DEFAULT_USE_IMPLICIT_FRICTION
```
  - myProps
```
public static PropertyList myProps
```
- Constructor Detail
  - MechSystemBase
```
public MechSystemBase(java.lang.String name)
```
- Method Detail
  - setPenetrationLimit
```
public void setPenetrationLimit(double lim)
```
  - getPenetrationLimit
```
public double getPenetrationLimit()
```
  - getDynamicsEnabled
```
public boolean getDynamicsEnabled()
```
  - setDynamicsEnabled
```
public void setDynamicsEnabled(boolean enable)
```
  - topMechSystem
```
public static MechSystem topMechSystem(ModelComponent comp)
```
    Returns the topmost MechSystem, if any, that is associated with a specific component.
    
    Parameters:
    
    comp - component to start with
    
    Returns:
    
    topmost MechSystem on or above comp, or null if there is none.
  - getSolver
```
public MechSystemSolver getSolver()
```
  - createVelocityJacobian
```
public SparseBlockMatrix createVelocityJacobian()
```
  - reduceVelocityJacobian
```
public void reduceVelocityJacobian(SparseBlockMatrix J)
```
  - getNumUnilateralForces
```
public int getNumUnilateralForces()
```
  - getUnilateralConstraintSizes
```
public void getUnilateralConstraintSizes(VectorNi sizes)
```
  - getUnilateralConstraints
```
public void getUnilateralConstraints(SparseBlockMatrix NT,
                                     VectorNd dn)
```
    Description copied from interface: MechSystem
    Obtains the transpose of the current unilateral constraint matrix N for this system. This is built and stored in NT. On input, NT should be empty with zero size; it will be sized appropriately by the system. The derivative term is returned in dn; this is given by
```
 dn/dt u
 
```
    where u is the current system velocity. dn will also be sized appropriately by the system.
    Specified by:
    
    getUnilateralConstraints in interface MechSystem
    
    Parameters:
    
    NT - returns the transpose of N
    
    dn - if non-null. returns the derivative term for N
  - getNumBilateralForces
```
public int getNumBilateralForces()
```
  - getBilateralConstraintSizes
```
public void getBilateralConstraintSizes(VectorNi sizes)
```
  - isBilateralStructureConstant
```
public boolean isBilateralStructureConstant()
```
    Queries whether or not the matrix structure of the bilateral constraints returned by this system is constant for a given structure version.
    
    Specified by:
    
    isBilateralStructureConstant in interface MechSystem
    
    Returns:
    
    true if bilateral constraints have a constant structure
  - getBilateralConstraints
```
public void getBilateralConstraints(SparseBlockMatrix GT,
                                    VectorNd dg)
```
    Description copied from interface: MechSystem
    Obtains the transpose of the current bilateral constraint matrix G for this system. This is built and stored in GT. On input, GT should be empty with zero size; it will be sized appropriately by the system. The derivative term is returned in dg; this is given by
```
 dG/dt u
 
```
    where u is the current system velocity. dg will also be sized appropriately by the system.
    Specified by:
    
    getBilateralConstraints in interface MechSystem
    
    Parameters:
    
    GT - returns the transpose of G
    
    dg - if non-null, returns the derivative term for G
  - getBilateralInfo
```
public void getBilateralInfo(MechSystem.ConstraintInfo[] ginfo)
```
    Description copied from interface: MechSystem
    
    Obtains information for all the constraint directions returned by the most recent call to getBilateralConstraints(). The information is returned in the array ginfo, which should contain preallocated ConstraintInfo structures and should have a length greater or equal to the column size of GT returned by getBilateralConstraints().
    
    Specified by:
    
    getBilateralInfo in interface MechSystem
    
    Parameters:
    
    ginfo - Array of ConstraintInfo objects used to return the constraint information.
  - setBilateralForces
```
public void setBilateralForces(VectorNd lam,
                               double s)
```
    Description copied from interface: MechSystem
    
    Supplies to the system the most recently computed bilateral constraint forces. These are supplied in the form lam*s, where lam is a vector of impulses and s is the inverse of the step size used in the computation. lam, which should have a size greater or equal to the column size of GT returned by getBilateralConstraints().
    
    Specified by:
    
    setBilateralForces in interface MechSystem
    
    Parameters:
    
    lam - When scaled by s, gives the bilateral constraint forces being supplied to the system.
    
    s - Scaling factor to be applied to the lam.
  - setBilateralForces
```
public int setBilateralForces(VectorNd lam,
                              double s,
                              int idx)
```
  - getBilateralForces
```
public void getBilateralForces(VectorNd lam)
```
    Description copied from interface: MechSystem
    
    Returns from the system the most recently computed bilateral constraint forces. These are stored in the vector lam, which should have a size greater or equal to the column size of GT returned by getBilateralConstraints(). For constraints which where present in the previous solve step, the force values should equal those which were set by the prevous call to setBilateralForces(). Otherwise, values can be estimated from previous force values (where appropriate), or supplied as 0.
    
    Specified by:
    
    getBilateralForces in interface MechSystem
    
    Parameters:
    
    lam - Bilateral constraint forces being returned from the system.
  - getBilateralForces
```
public int getBilateralForces(VectorNd lam,
                              int idx)
```
  - getUnilateralInfo
```
public void getUnilateralInfo(MechSystem.ConstraintInfo[] ninfo)
```
    Description copied from interface: MechSystem
    
    Obtains information for all the constraint directions returned by the most recent call to getUnilateralConstraints(). The information is returned in the array ninfo, which should contain preallocated ConstraintInfo structures and should have a length greater or equal to the column size of NT returned by getUnilateralConstraints().
    
    Specified by:
    
    getUnilateralInfo in interface MechSystem
    
    Parameters:
    
    ninfo - Array of ConstraintInfo objects used to return the constraint information.
  - setUnilateralForces
```
public void setUnilateralForces(VectorNd the,
                                double s)
```
    Description copied from interface: MechSystem
    
    Supplies to the system the most recently computed unilateral constraint forces. These are supplied in the form the*s, where the is a vector of impulses and s is the inverse of the step size used in the computation. the should have a size greater or equal to the column size of NT returned by getUnilateralConstraints().
    
    Specified by:
    
    setUnilateralForces in interface MechSystem
    
    Parameters:
    
    the - When scaled by s, gives the unilateral constraint forces being supplied to the system.
    
    s - Scaling factor to be applied to the the.
  - setUnilateralForces
```
public int setUnilateralForces(VectorNd the,
                               double s,
                               int idx)
```
  - getUnilateralForces
```
public void getUnilateralForces(VectorNd the)
```
    Description copied from interface: MechSystem
    
    Returns from the system the most recently computed unilateral constraint forces. These are stored in the vector the, which should have a size greater or equal to the column size of NT returned by getUnilateralConstraints(). For constraints which where present in the previous solve step, the force values should equal those which were set by the previous call to setUnilateralForces(). Otherwise, values can be estimated from previous force values (where appropriate), or supplied as 0.
    
    Specified by:
    
    getUnilateralForces in interface MechSystem
    
    Parameters:
    
    the - Unilateral constraint forces being returned from the system.
  - getUnilateralForces
```
public int getUnilateralForces(VectorNd the,
                               int idx)
```
  - setUnilateralState
```
public void setUnilateralState(VectorNi state)
```
  - setUnilateralState
```
public int setUnilateralState(VectorNi state,
                              int idx)
```
    Specified by:
    
    setUnilateralState in interface MechSystem
  - getUnilateralState
```
public void getUnilateralState(VectorNi state)
```
  - getUnilateralState
```
public int getUnilateralState(VectorNi state,
                              int idx)
```
    Specified by:
    
    getUnilateralState in interface MechSystem
  - maxFrictionConstraintSets
```
public int maxFrictionConstraintSets()
```
    Description copied from interface: MechSystem
    
    Returns that maximum number of friction constraint set that may be added by the method getFrictionConstraints(). This is used to size the finfo array supplied to that method.
    
    Specified by:
    
    maxFrictionConstraintSets in interface MechSystem
    
    Returns:
    
    maximum friction constraint sets
  - getFrictionConstraints
```
public int getFrictionConstraints(SparseBlockMatrix DT,
                                  java.util.ArrayList<FrictionInfo> finfo,
                                  boolean prune)
```
    Description copied from interface: MechSystem
    
    Obtains the transpose of the current friction constraint matrix D for this system. This is built and stored in DT. On input, DT should be empty with zero size; it will be sized appropriately by the system.
    Each column block in DT describes a friction constraint set associated with one unilateral or bilateral constraint. Information about each friction constraint set is returned in the array finfo, which should contain preallocated FrictionInfo structures and should have a length greater or equal to the value returned by FrictionConstraintSets().
    
    Specified by:
    
    getFrictionConstraints in interface MechSystem
    
    Parameters:
    
    DT - returns the transpose of D
    
    finfo - returns information for each friction constraint set
    
    prune - limit DT entries to those for which the corresponding contact forces are > 0
    
    Returns:
    
    number of friction entries
  - setFrictionForces
```
public void setFrictionForces(VectorNd phi,
                              double s)
```
    Description copied from interface: MechSystem
    
    Supplies to the system the most recently computed friction constraint forces. These are supplied in the form phi*s, where phi is a vector of impulses and s is the inverse of the step size used in the computation. phi should have a size greater or equal to the column size of DT returned by getFrictionConstraints().
    
    Specified by:
    
    setFrictionForces in interface MechSystem
    
    Parameters:
    
    phi - When scaled by s, gives the friction constraint forces being supplied to the system.
    
    s - Scaling factor to be applied to the phi.
  - setFrictionForces
```
public int setFrictionForces(VectorNd phi,
                             double s,
                             int idx)
```
  - getFrictionForces
```
public void getFrictionForces(VectorNd phi)
```
    Description copied from interface: MechSystem
    
    Returns from the system the most recently computed friction constraint forces. These are stored in the vector phi, which should have a size greater or equal to the column size of DT returned by getFrictionConstraints(). For constraints which where present in the previous solve step, the force values should equal those which were set by the previous call to setFrictionForces(). Otherwise, values can be estimated from previous force values (where appropriate), or supplied as 0.
    
    Specified by:
    
    getFrictionForces in interface MechSystem
    
    Parameters:
    
    phi - Unilateral constraint forces being returned from the system.
  - getFrictionForces
```
public int getFrictionForces(VectorNd phi,
                             int idx)
```
  - setFrictionState
```
public void setFrictionState(VectorNi state)
```
  - setFrictionState
```
public int setFrictionState(VectorNi state,
                            int idx)
```
    Specified by:
    
    setFrictionState in interface MechSystem
  - getFrictionState
```
public void getFrictionState(VectorNi state)
```
  - getFrictionState
```
public int getFrictionState(VectorNi state,
                            int idx)
```
    Specified by:
    
    getFrictionState in interface MechSystem
  - updateConstraints
```
public boolean updateConstraints(double t,
                                 StepAdjustment stepAdjust,
                                 int flags)
```
    Description copied from interface: MechSystem
    
    Updates the constraints associated with this system to be consistent with the current position and indicated time. This method should be called between any change to position values and any call that obtains constraint information (such as getBilateralConstraints().
    Because contact computations are expensive, the constraints associated with contact should only be computed if the flags MechSystem.COMPUTE_CONTACTS or MechSystem.UPDATE_CONTACTS are specified. The former calls for contact information to be computed from scratch, while the latter calls for contact information to be modified to reflect changes in body positions, while preserving the general contact state between bodies.
    In the process of updating the constraints, the system may determine that a smaller step size is needed. This is particulary true when contact calculations show an unacceptable level of interpenetration. A smaller step size can be recommended If so, it can indicate this through the optional argument stepAdjust, if present.
    
    Specified by:
    
    updateConstraints in interface MechSystem
    
    Parameters:
    
    t - current time
    
    stepAdjust - (optional) can be used to indicate whether the current advance should be redone with a smaller step size.
    
    flags - information flags
    
    Returns:
    
    true if the system contains constraints
  - getStructureVersion
```
public int getStructureVersion()
```
    Description copied from interface: MechSystem
    
    Returns the current structure version of this system. The structure version should be incremented whenever the number and arrangement of active and parametric components changes, implying that any mass and solve matrices should be be rebuilt.
    
    Specified by:
    
    getStructureVersion in interface MechSystem
    
    Returns:
    
    current structure version number for this system
  - getDynamicDOFs
```
public void getDynamicDOFs(int[] dofs)
```
    Returns in sizes the number of (velocity) degrees of freedom for the dynamic components in the system. The results are arranged according to each component's solveIndex. If the length of sizes is less than the number of dynamic components, the results are truncated.
    
    Parameters:
    
    dofs - returns the number of DOFs for each dynamic component
  - placeDynamicComponent
```
public static void placeDynamicComponent(java.util.List<DynamicComponent> active,
                                         java.util.List<DynamicComponent> attached,
                                         java.util.List<DynamicComponent> parametric,
                                         DynamicComponent d)
```
  - getDynamicComponents
```
public java.util.ArrayList<DynamicComponent> getDynamicComponents()
```
    Returns a list of the dynamic components in this model. Used for debugging only. Must not be modified.
  - updateDynamicComponentLists
```
public void updateDynamicComponentLists()
```
  - getForceEffectors
```
public java.util.ArrayList<ForceEffector> getForceEffectors()
```
    Returns a list of the force effectors in this model. Used for debugging only. Must not be modified.
  - updateForceComponentList
```
public void updateForceComponentList()
```
  - getSlaveObjectComponents
```
public void getSlaveObjectComponents(java.util.List<HasSlaveObjects> comps,
                                     int level)
```
    Should be overridden in subclasses to return all the HasSlaveObjects components within this model.
    
    Specified by:
    
    getSlaveObjectComponents in interface MechSystemModel
    
    Parameters:
    
    comps - HasSlaveObjects components should be added to this list
  - getActivePosState
```
public void getActivePosState(VectorNd q)
```
    Gets the current position state for all active components. This is stored in the vector q (which will be sized appropriately by the system).
    
    Specified by:
    
    getActivePosState in interface MechSystem
    
    Parameters:
    
    q - vector in which the state is stored
  - getActiveVelState
```
public void getActiveVelState(VectorNd u)
```
    Gets the current velocity state for all active components. This is stored in the vector u (which will be sized appropriately by the system).
    
    Specified by:
    
    getActiveVelState in interface MechSystem
    
    Parameters:
    
    u - vector in which the state is stored
  - getActiveVelState
```
public int getActiveVelState(VectorNd u,
                             int idx,
                             boolean bodyCoords)
```
  - setActivePosState
```
public void setActivePosState(VectorNd q)
```
    Sets the current position state for all active components. This is supplied in the vector q, whose size should be greater than or equal to the value returned by getActivePosStateSize().
    
    Specified by:
    
    setActivePosState in interface MechSystem
    
    Parameters:
    
    q - vector supplying the state information
  - addActivePosImpulse
```
public void addActivePosImpulse(VectorNd x,
                                double h,
                                VectorNd v)
```
    Description copied from interface: MechSystem
    Computes an adjustment to the active positions of the system (stored in the vector q) by applying a velocity u for time h. Where velocity equals position derivative, this corresponds to computing
```
 q += h u.
 
```
    In other situations, such as where position is orientation expressed as a quaternion and velocity is angular velocity, the system should perform the analagous computation. q should have a size greater or equal to the value returned by getActivePosStateSize(), and u should have a size greater or equal to the value returned by getActiveVelStateSize().
    Specified by:
    
    addActivePosImpulse in interface MechSystem
    
    Parameters:
    
    x - positions to be adjusted
    
    h - length of time to apply velocity
    
    v - velocity to be applied
  - setActiveVelState
```
public void setActiveVelState(VectorNd u)
```
    Sets the current velocity state for all active components. This is supplied in the vector u, whose size should be greater than or equal to the value returned by getActiveVelStateSize().
    
    Specified by:
    
    setActiveVelState in interface MechSystem
    
    Parameters:
    
    u - vector supplying the state information
  - getActivePosStateSize
```
public int getActivePosStateSize()
```
    Returns the size of the position state for all active components. This should remain unchanged as long as the current structure version (returned by getStructureVersion() remains unchanged.
    
    Specified by:
    
    getActivePosStateSize in interface MechSystem
    
    Returns:
    
    size of the active position state
  - getActiveVelStateSize
```
public int getActiveVelStateSize()
```
    Returns the size of the velocity state for all active components. This should remain unchanged as long as the current structure version (returned by getStructureVersion() remains unchanged.
    
    Specified by:
    
    getActiveVelStateSize in interface MechSystem
    
    Returns:
    
    size of the velocity state
  - getActivePosDerivative
```
public void getActivePosDerivative(VectorNd dxdt,
                                   double t)
```
    Description copied from interface: MechSystem
    
    Gets the current value of the position derivative for all active components. This is stored in the vector dxdt (which will be sized appropriately by the system).
    
    Specified by:
    
    getActivePosDerivative in interface MechSystem
    
    Parameters:
    
    dxdt - vector in which the derivative is stored
    
    t - current time value
  - getActiveDynamicComponents
```
public java.util.ArrayList<DynamicComponent> getActiveDynamicComponents()
```
    Returns a list of all the active dynamic components, which collectively determine the values returned by getActiveForces(maspack.matrix.VectorNd), getActivePosState(maspack.matrix.VectorNd), etc. The returned list is a copy and may be modified.
    
    Returns:
    
    list of all the active dynamic components.
  - getActiveForces
```
public void getActiveForces(VectorNd f)
```
    Returns the generalized forces acting on all the active components in this system. This is stored in the vector f (which will be sized appropriately by the system).
    
    Specified by:
    
    getActiveForces in interface MechSystem
    
    Parameters:
    
    f - vector in which the forces are stored
  - setActiveForces
```
public void setActiveForces(VectorNd f)
```
    Sets the generalized forces acting on all the active components in this system. The values are specifies in the vector f, whose size should be greater or equal to the value returned by getActiveVelStateSize().
    
    Specified by:
    
    setActiveForces in interface MechSystem
    
    Parameters:
    
    f - vector specifying the forces to be set
  - getForces
```
public void getForces(VectorNd f)
```
  - setForces
```
public void setForces(VectorNd f)
```
  - getParametricForces
```
public void getParametricForces(VectorNd f)
```
    Gets the forces associated with parametric components. This is returned in the vector f (which will be sized appropriately by the system).
    
    Specified by:
    
    getParametricForces in interface MechSystem
    
    Parameters:
    
    f - vector in which to return the force information
  - setParametricForces
```
public void setParametricForces(VectorNd f)
```
    Sets the forces associated with parametric components. This is supplied in the vector f, whose size should be greater or equal to the value returned by getParametricVelStateSize().
    
    Specified by:
    
    setParametricForces in interface MechSystem
    
    Parameters:
    
    f - vector supplying the force information
  - getPrintState
```
public java.lang.String getPrintState()
```
  - setPrintState
```
public void setPrintState(java.lang.String fmt,
                          double interval)
```
  - setPrintState
```
public void setPrintState(java.lang.String fmt)
```
  - openPrintStateFile
```
public java.io.PrintWriter openPrintStateFile(java.lang.String fileName)
                                       throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - reopenPrintStateFile
```
public java.io.PrintWriter reopenPrintStateFile(java.lang.String fileName)
                                         throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - closePrintStateFile
```
public void closePrintStateFile()
                         throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - writePrintStateHeader
```
public void writePrintStateHeader(java.lang.String description)
```
  - preadvance
```
public StepAdjustment preadvance(double t0,
                                 double t1,
                                 int flags)
```
    Description copied from class: ModelBase
    
    Prepares this model for advance from time t0 to time t1. Often this method does nothing; it is provided in case a model needs to update internal state at the very beginning a step before input probes and controllers are applied.
    If the method determines that the step size should be reduced, it can return a StepAdjustment object indicating the recommended reduction. Otherwise, the method may return null
    The flags argument gives additional information that may be relevant when advancing the model. Currently implemented flags include Model.STATE_IS_VOLATILE.
    
    Specified by:
    
    preadvance in interface Model
    
    Overrides:
    
    preadvance in class ModelBase
    
    Parameters:
    
    t0 - current time (seconds)
    
    t1 - new time to advance to (seconds)
    
    flags - additional information relevant to the advance
    
    Returns:
    
    null, or a step adjustment recommendation
  - advance
```
public StepAdjustment advance(double t0,
                              double t1,
                              int flags)
```
    Description copied from class: ModelBase
    
    Advances this model from time t0 to time t1.
    If the method determines that the step size should be reduced, it can return a StepAdjustment object indicating the recommended reduction. Otherwise, the method may return null
    The flags argument gives additional information that may be relevant when advancing the model. Currently implemented flags include Model.STATE_IS_VOLATILE.
    
    Specified by:
    
    advance in interface Model
    
    Specified by:
    
    advance in class ModelBase
    
    Parameters:
    
    t0 - current time (seconds)
    
    t1 - new time to advance to (seconds)
    
    flags - rdditional information relevant to the advance
    
    Returns:
    
    null, or a step adjustment recommendation
  - createState
```
public ComponentState createState(ComponentState prevState)
```
    Description copied from class: ModelBase
    
    Factory routine to create a state object for this component, which can then be used as an argument for HasState.setState(artisynth.core.modelbase.ComponentState) and HasState.getState(artisynth.core.modelbase.ComponentState). The state object does not have to be set to the component's current state. If the component does not have any state information, this method should return an instance of EmptyState.
    
    Specified by:
    
    createState in interface HasState
    
    Overrides:
    
    createState in class ModelBase
    
    Parameters:
    
    prevState - If non-null, supplies a previous state that was created by this component and which can be used to provide pre-sizing hints.
    
    Returns:
    
    new object for storing this component's state
  - setState
```
public void setState(ComponentState pstate)
```
    Description copied from class: ModelBase
    
    Set the state of this component.
    
    Specified by:
    
    setState in interface HasState
    
    Overrides:
    
    setState in class ModelBase
    
    Parameters:
    
    pstate - state to be copied
  - getState
```
public void getState(ComponentState pstate)
```
    Description copied from class: ModelBase
    
    Get the current state of this component.
    
    Specified by:
    
    getState in interface HasState
    
    Overrides:
    
    getState in class ModelBase
    
    Parameters:
    
    pstate - receives the state information
  - getInitialState
```
public void getInitialState(ComponentState newstate,
                            ComponentState oldstate)
```
    Description copied from class: ModelBase
    
    Gets an initial state for this component and returns the value in state. If prevstate is non-null, then it is assumed to contain a previous initial state value returned by this method, and state should be set to be as consistent with this previous state as possible. For example, suppose that this component currently contains subcomponents A, B, and C, while the prevstate contains the state from a previous time when it had components B, C, and D. Then state should contain substate values for B and C that are taken from prevstate. To facilitate this, the information returned in state should contain additional information such as the identities of all the (current) subcomponents.
    
    Specified by:
    
    getInitialState in interface HasState
    
    Overrides:
    
    getInitialState in class ModelBase
    
    Parameters:
    
    newstate - receives the state information
    
    oldstate - previous state information; may be null.
  - initialize
```
public void initialize(double t)
```
    Description copied from class: ModelBase
    
    Causes this model to initialize itself at time t. This method will be called at the very beginning of the simulation (with t = 0), or immediately after the model's state has been reset using HasState.setState(artisynth.core.modelbase.ComponentState), in which case t may have an arbitrary value.
    
    Specified by:
    
    initialize in interface Model
    
    Overrides:
    
    initialize in class ModelBase
    
    Parameters:
    
    t - initialization time (seconds)
  - recursivelyInitialize
```
public void recursivelyInitialize(double t,
                                  int level)
```
    Specified by:
    
    recursivelyInitialize in interface MechSystemModel
  - recursivelyPrepareAdvance
```
public void recursivelyPrepareAdvance(double t0,
                                      double t1,
                                      int flags,
                                      int level)
```
    Specified by:
    
    recursivelyPrepareAdvance in interface MechSystemModel
  - recursivelyFinalizeAdvance
```
public void recursivelyFinalizeAdvance(StepAdjustment stepAdjust,
                                       double t0,
                                       double t1,
                                       int flags,
                                       int level)
```
    Specified by:
    
    recursivelyFinalizeAdvance in interface MechSystemModel
  - setProfiling
```
public void setProfiling(boolean enable)
```
  - getProfiling
```
public boolean getProfiling()
```
  - setDefaultMatrixSolver
```
public static void setDefaultMatrixSolver(SparseSolverId solverType)
```
  - getDefaultMatrixSolver
```
public static SparseSolverId getDefaultMatrixSolver()
```
  - setMatrixSolver
```
public void setMatrixSolver(SparseSolverId method)
```
  - getMatrixSolver
```
public SparseSolverId getMatrixSolver()
```
  - getMatrixSolverRange
```
public Range getMatrixSolverRange()
```
  - setIntegrator
```
public void setIntegrator(MechSystemSolver.Integrator integrator)
```
  - getUseImplicitFriction
```
public boolean getUseImplicitFriction()
```
  - setUseImplicitFriction
```
public void setUseImplicitFriction(boolean enable)
```
  - getDefaultUseImplicitFriction
```
public static boolean getDefaultUseImplicitFriction()
```
  - setDefaultUseImplicitFriction
```
public static void setDefaultUseImplicitFriction(boolean enable)
```
  - getIntegrator
```
public MechSystemSolver.Integrator getIntegrator()
```
  - numActiveComponents
```
public int numActiveComponents()
```
    Description copied from interface: MechSystem
    
    Returns the current number of active components in this system. This should remain unchanged as long as the current structure version (returned by getStructureVersion() remains unchanged.
    
    Specified by:
    
    numActiveComponents in interface MechSystem
    
    Returns:
    
    number of active components
  - numParametricComponents
```
public int numParametricComponents()
```
    Description copied from interface: MechSystem
    
    Returns the current number of parametric components in this system. This should remain unchanged as long as the current structure version (returned by getStructureVersion() remains unchanged.
    
    Specified by:
    
    numParametricComponents in interface MechSystem
    
    Returns:
    
    number of parametric components
  - numAttachedComponents
```
public int numAttachedComponents()
```
  - getAttachmentConstraints
```
public SparseBlockMatrix getAttachmentConstraints()
```
    Returns the transpose of the attachment constraint matrix. This is used only for debugging.
    
    Returns:
    
    transposed attachment constraint matrix
  - getAttachmentDerivatives
```
public VectorNd getAttachmentDerivatives()
```
  - addAttachmentJacobian
```
public void addAttachmentJacobian(SparseNumberedBlockMatrix S,
                                  VectorNd f)
```
  - addAttachmentSolveBlocks
```
public void addAttachmentSolveBlocks(SparseNumberedBlockMatrix S)
```
  - updateAttachmentPos
```
public void updateAttachmentPos()
```
  - updateAttachmentVel
```
public void updateAttachmentVel()
```
  - updatePosState
```
public void updatePosState()
```
  - updateVelState
```
public void updateVelState()
```
  - applyAttachmentForces
```
public void applyAttachmentForces()
```
  - buildMassMatrix
```
public boolean buildMassMatrix(SparseNumberedBlockMatrix M)
```
    Description copied from interface: MechSystem
    
    Builds a mass matrix for this system. This is done by adding blocks of an appropriate type to the sparse block matrix M. On input, M should be empty with zero size; it will be sized appropriately by the system.
    This method returns true if the mass matrix is constant; i.e., does not vary with time. It does not place actual values in the matrix; that must be done by calling getMassMatrix().
    A new mass matrix should be built whenever the system's structure version (as returned by getStructureVersion()) changes.
    
    Specified by:
    
    buildMassMatrix in interface MechSystem
    
    Parameters:
    
    M - matrix in which the mass matrix will be built
    
    Returns:
    
    true if the mass matrix is constant.
  - getMassMatrix
```
public void getMassMatrix(SparseNumberedBlockMatrix M,
                          VectorNd f,
                          double t)
```
    Description copied from interface: MechSystem
    Sets M to the current value of the mass matrix for this system, evaluated at time t. M should have been previously created with a call to buildMassMatrix(). The current mass forces are returned in the vector f, which should have a size greater or equal to the size of M. The mass forces (also known as the fictitious forces) are given by
```
 - dM/dt u
 
```
    where u is the current system velocity. f will be sized appropriately by the system.
    Specified by:
    
    getMassMatrix in interface MechSystem
    
    Parameters:
    
    M - returns the mass matrix
    
    f - returns the mass forces
    
    t - current time
  - getInverseMassMatrix
```
public void getInverseMassMatrix(SparseBlockMatrix Minv,
                                 SparseBlockMatrix M)
```
    Description copied from interface: MechSystem
    
    Sets Minv to the inverse of the mass matrix M. Minv should have been previously created with a call to buildMassMatrix().
    This method assumes that M is block diagonal and hence Minv has the same block structure. Although it is possible to compute Minv by simply inverting each block of M, the special structure of each mass block may permit the system to do this in a highly optimized way.
    
    Specified by:
    
    getInverseMassMatrix in interface MechSystem
    
    Parameters:
    
    Minv - returns the inverted mass matrix
    
    M - mass matrix to invert
  - buildSolveMatrix
```
public void buildSolveMatrix(SparseNumberedBlockMatrix S)
```
    Description copied from interface: MechSystem
    
    Builds a solve matrix for this system. This is done by adding blocks of an appropriate type to the sparse block matrix S. On input, S should be empty with zero size; it will be sized appropriately by the system. The resulting matrix should have all the blocks required to store any combination of the mass matrix, the force-position Jacobian, and the force-velocity Jacobian. This method does not place actual values in the matrix; that must be done by adding a mass matrix to it, or by calling addVelJacobian() or addPosJacobian().
    A new solve matrix should be built whenever the system's structure version (as returned by getStructureVersion()) changes.
    
    Specified by:
    
    buildSolveMatrix in interface MechSystem
    
    Parameters:
    
    S - matrix in which the solve matrix will be built
  - getDefaultStabilization
```
public static MechSystemSolver.PosStabilization getDefaultStabilization()
```
  - setDefaultStabilization
```
public static void setDefaultStabilization(MechSystemSolver.PosStabilization stablizer)
```
  - getStabilization
```
public MechSystemSolver.PosStabilization getStabilization()
```
  - setStabilization
```
public void setStabilization(MechSystemSolver.PosStabilization stablizer)
```
  - setUpdateForcesAtStepEnd
```
public void setUpdateForcesAtStepEnd(boolean enable)
```
  - getUpdateForcesAtStepEnd
```
public boolean getUpdateForcesAtStepEnd()
```
  - setUpdateForcesAtStepEndMode
```
public void setUpdateForcesAtStepEndMode(PropertyMode mode)
```
  - getUpdateForcesAtStepEndMode
```
public PropertyMode getUpdateForcesAtStepEndMode()
```
  - getParametricPosStateSize
```
public int getParametricPosStateSize()
```
    Returns the size of the position state for all parametric components. This should remain unchanged as long as the current structure version (returned by getStructureVersion() remains unchanged.
    
    Specified by:
    
    getParametricPosStateSize in interface MechSystem
    
    Returns:
    
    size of the parametric position state
  - getParametricPosTarget
```
public void getParametricPosTarget(VectorNd q,
                                   double s,
                                   double h)
```
    Obtains the desired target position for all parametric components at a particular time. This is stored in the vector q (which will be sized appropriately by the system). The system interpolates between the current parametric position values and those desired for the end of the time step, using a parameter s defined on the interval [0,1]. In particular, specifying s = 0 yields the current parametric positions, and s = 1 yields the positions desired for the end of the step. The actual time step size h is also provided, as this may be needed by some interpolation methods.
    The interpolation uses the current parametric positions, and possibly the current parametric velocities as well. Hence this method should be called before either of these are changed using setParametricPosState() or setParametricVelState().
    
    Specified by:
    
    getParametricPosTarget in interface MechSystem
    
    Parameters:
    
    q - vector returning the state information
    
    s - specifies time relative to the current time step
    
    h - time step size
  - getParametricPosState
```
public void getParametricPosState(VectorNd q)
```
    Gets the current position state for all parametric components. This is stored in the vector q (which will be sized appropriately by the system).
    
    Specified by:
    
    getParametricPosState in interface MechSystem
    
    Parameters:
    
    q - vector in which the state is stored
  - setParametricPosState
```
public void setParametricPosState(VectorNd q)
```
    Sets the current position state for all parametric components. This is supplied in the vector q, whose size should be greater than or equal to the value returned by getParametricPosStateSize().
    
    Specified by:
    
    setParametricPosState in interface MechSystem
    
    Parameters:
    
    q - vector supplying the state information
  - getParametricVelStateSize
```
public int getParametricVelStateSize()
```
    Returns the size of the velocity state for all parametric components. This should remain unchanged as long as the current structure version (returned by getStructureVersion() remains unchanged.
    
    Specified by:
    
    getParametricVelStateSize in interface MechSystem
    
    Returns:
    
    size of the parametric velocity state
  - getParametricVelTarget
```
public void getParametricVelTarget(VectorNd u,
                                   double s,
                                   double h)
```
    Obtains the desired target velocity for all parametric components at a particular time. This is stored in the vector u (which will be sized appropriately by the system). The system interpolates between the current parametric velocity values and those desired for the end of the time step, using a parameter s defined on the interval [0,1]. In particular, specifying s = 0 yields the current parametric velocities, and s = 1 yields the velocities desired for the end of the step. The actual time step size h is also provided, as this may be needed by some interpolation methods.
    The interpolation uses the current parametric velocities, and possibly the current parametric positions as well. Hence this method should be called before either of these are changed using setParametricPosState() or setParametricVelState().
    
    Specified by:
    
    getParametricVelTarget in interface MechSystem
    
    Parameters:
    
    u - vector returning the parametric target velocites
    
    s - specifies time relative to the current time step
    
    h - time step size
  - getParametricVelState
```
public void getParametricVelState(VectorNd u)
```
    Gets the current velocity state for all parametric components. This is stored in the vector u (which will be sized appropriately by the system).
    
    Specified by:
    
    getParametricVelState in interface MechSystem
    
    Parameters:
    
    u - vector in which state is stored
  - setParametricVelState
```
public void setParametricVelState(VectorNd q)
```
    Sets the current velocity state for all parametric components. This is supplied in the vector u, whose size should be greater than or equal to the value returned by getParametricVelStateSize().
    
    Specified by:
    
    setParametricVelState in interface MechSystem
    
    Parameters:
    
    q - vector supplying the state information
  - copy
```
public MechSystemBase copy(int flags,
                           java.util.Map<ModelComponent,ModelComponent> copyMap)
```
    Overrides:
    
    copy in class ComponentList<ModelComponent>
  - printActiveStiffness
```
public void printActiveStiffness()
```
  - printActiveStiffness
```
public void printActiveStiffness(java.lang.String fmtStr)
```
  - getActiveStiffnessMatrix
```
public SparseBlockMatrix getActiveStiffnessMatrix()
```
  - getActiveDampingMatrix
```
public SparseBlockMatrix getActiveDampingMatrix()
```
  - printActiveMass
```
public void printActiveMass()
```
  - printActiveMass
```
public void printActiveMass(java.lang.String fmtStr)
```
  - getActiveMassMatrix
```
public SparseBlockMatrix getActiveMassMatrix()
```
  - writeStiffnessMatrix
```
public void writeStiffnessMatrix(java.lang.String fileName,
                                 double h,
                                 Matrix.WriteFormat matfmt)
                          throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - writeStiffnessMatrix
```
public void writeStiffnessMatrix(java.lang.String fileName,
                                 double h)
                          throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - writeMassMatrix
```
public void writeMassMatrix(java.lang.String fileName,
                            Matrix.WriteFormat matfmt)
                     throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - writeMassMatrix
```
public void writeMassMatrix(java.lang.String fileName)
                     throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - writeBilateralConstraintMatrix
```
public void writeBilateralConstraintMatrix(java.lang.String fileName,
                                           Matrix.WriteFormat matfmt)
                                    throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - writeBilateralConstraintMatrix
```
public void writeBilateralConstraintMatrix(java.lang.String fileName)
                                    throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - collectInitialForces
```
public void collectInitialForces()
```
  - updateForces
```
public void updateForces(double t)
```
    Description copied from interface: MechSystem
    
    Updates all internal forces associated with this system to be consistent with the current position and velocity and the indicated time t. This method should be called between any change to position or velocity values (such as through setActivePosState() or setActiveVelState(), and any call to getActiveForces().
    In the process of updating the forces, the system may determine that a smaller step size is needed. If so, it can indicate this through the argument optional stepAdjust, if present.
    
    Specified by:
    
    updateForces in interface MechSystem
    
    Parameters:
    
    t - current time
  - addPosJacobian
```
public void addPosJacobian(SparseNumberedBlockMatrix S,
                           VectorNd f,
                           double s)
```
    Description copied from interface: MechSystem
    
    Adds the current force-position Jacobian, scaled by h, to the matrix S, which should have been previously created with a call to buildSolveMatrix(). Addition fictitious forces associated with the Jacobian can be optionally returned in the vector f, which will be sized appropriately by the system.
    
    Specified by:
    
    addPosJacobian in interface MechSystem
    
    Parameters:
    
    S - matrix to which scaled Jacobian is to be added
    
    f - if non-null, returns fictitious forces associated with the Jacobian
    
    s - scale factor for the Jacobian
  - addVelJacobian
```
public void addVelJacobian(SparseNumberedBlockMatrix S,
                           VectorNd f,
                           double s)
```
    Description copied from interface: MechSystem
    
    Adds the current force-velocity Jacobian, scaled by h, to the matrix S, which should have been previously created with a call to buildSolveMatrix(). Addition fictitious forces associated with the Jacobian can be optionally returned in the vector f, which will be sized appropriately by the system.
    
    Specified by:
    
    addVelJacobian in interface MechSystem
    
    Parameters:
    
    S - matrix to which scaled Jacobian is to be added
    
    f - if non-null, returns fictitious forces associated with the Jacobian
    
    s - scale factor for the Jacobian
  - addGeneralMassBlocks
```
public void addGeneralMassBlocks(SparseNumberedBlockMatrix M)
```
    Specified by:
    
    addGeneralMassBlocks in interface MechSystemModel
  - addGeneralSolveBlocks
```
public void addGeneralSolveBlocks(SparseNumberedBlockMatrix M)
```
  - getActiveMass
```
public double getActiveMass()
```
  - getSolveMatrixType
```
public int getSolveMatrixType()
```
    Description copied from interface: MechSystem
    
    Returns information about the solve matrix for this system. This consists of an or-ed set of flags, including SYMMETRIC or POSITIVE_DEFINITE, which aid in determining the best way to solve the matrix.
    
    Specified by:
    
    getSolveMatrixType in interface MechSystem
    
    Returns:
    
    type information for the solve matrix
  - advanceAuxState
```
public void advanceAuxState(double t0,
                            double t1)
```
    Specified by:
    
    advanceAuxState in interface MechSystem
  - getAuxAdvanceState
```
public void getAuxAdvanceState(DataBuffer buf)
```
    Specified by:
    
    getAuxAdvanceState in interface MechSystem
  - setAuxAdvanceState
```
public void setAuxAdvanceState(DataBuffer buf)
```
    Specified by:
    
    setAuxAdvanceState in interface MechSystem
  - getAuxVarStateSize
```
public int getAuxVarStateSize()
```
    Specified by:
    
    getAuxVarStateSize in interface MechSystem
  - getAuxVarState
```
public void getAuxVarState(VectorNd w)
```
    Specified by:
    
    getAuxVarState in interface MechSystem
  - setAuxVarState
```
public void setAuxVarState(VectorNd w)
```
    Specified by:
    
    setAuxVarState in interface MechSystem
  - getAuxVarDerivative
```
public void getAuxVarDerivative(VectorNd dwdt)
```
    Specified by:
    
    getAuxVarDerivative in interface MechSystem

Class MechSystemBase

Nested Class Summary

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

Nested classes/interfaces inherited from interface artisynth.core.mechmodels.MechSystem

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

Field Summary

Fields inherited from class artisynth.core.modelbase.ModelBase

Fields inherited from class artisynth.core.modelbase.ComponentList

Fields inherited from class artisynth.core.modelbase.ModelComponentBase

Fields inherited from interface artisynth.core.modelbase.Model

Fields inherited from interface artisynth.core.mechmodels.MechSystem

Fields inherited from interface maspack.render.IsRenderable

Constructor Summary

Method Summary

Methods inherited from class artisynth.core.modelbase.RenderableModelBase

Methods inherited from class artisynth.core.modelbase.ModelBase

Methods inherited from class artisynth.core.modelbase.ComponentList

Methods inherited from class artisynth.core.modelbase.ModelComponentBase

Methods inherited from class java.lang.Object

Methods inherited from interface artisynth.core.mechmodels.MechSystemModel

Methods inherited from interface artisynth.core.modelbase.Model

Methods inherited from interface artisynth.core.modelbase.ModelComponent

Methods inherited from interface maspack.properties.HasProperties

Methods inherited from interface maspack.properties.HierarchyNode

Methods inherited from interface artisynth.core.modelbase.PostScannable

Methods inherited from interface maspack.util.Scannable

Methods inherited from interface artisynth.core.modelbase.ComponentListView

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Methods inherited from interface artisynth.core.modelbase.CompositeComponent

Field Detail

mySaveForcesAsState

myParametricsInSystemMatrix

useAllDynamicComps

DEFAULT_STABILIZATION

DEFAULT_USE_IMPLICIT_FRICTION

myProps

Constructor Detail

MechSystemBase

Method Detail

setPenetrationLimit

getPenetrationLimit

getDynamicsEnabled

setDynamicsEnabled

topMechSystem

getSolver

createVelocityJacobian

reduceVelocityJacobian

getNumUnilateralForces

getUnilateralConstraintSizes

getUnilateralConstraints

getNumBilateralForces

getBilateralConstraintSizes

isBilateralStructureConstant

getBilateralConstraints

getBilateralInfo

setBilateralForces

setBilateralForces

getBilateralForces

getBilateralForces

getUnilateralInfo

setUnilateralForces

setUnilateralForces

getUnilateralForces

getUnilateralForces

setUnilateralState

setUnilateralState

getUnilateralState

getUnilateralState

maxFrictionConstraintSets

getFrictionConstraints

setFrictionForces

setFrictionForces

getFrictionForces

getFrictionForces

setFrictionState

setFrictionState

getFrictionState

getFrictionState

updateConstraints