DynamicAgent (Artisynth API documentation)

All Superinterfaces:

HasNumericState

All Known Subinterfaces:

CollidableDynamicComponent, DynamicComponent, MotionTargetComponent

All Known Implementing Classes:

BackNode3d, BeamBody, DeformableBody, DicomPlaneViewer, DicomViewer, DynamicComponentBase, EBBeamBody, FemCutPlane, FemMarker, FemModelFrame, FemNode, FemNode3d, Frame, FrameMarker, FrameNode3d, GenericMarker, ImageViewer, JointBasedMovingMarker, JointConditionalMarker, Marker, MFreeNode3d, NiftiViewer, Particle, PlanarPoint, Point, RigidBody, RigidCompositeBody, RigidCylinder, RigidEllipsoid, RigidMesh, RigidSphere, RigidTorus, SkinMarker, TargetFrame, TargetPoint, TexturePlaneBase
```
public interface DynamicAgent
extends HasNumericState
```

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`addConstrainer(Constrainer c)` Adds a Constrainer to the list returned by `getConstrainers()`.
`int`	`addForce(double[] buf, int idx)`
`void`	`addMasterAttachment(DynamicAttachment a)` Add a DynamicAttachment to the list of master attachments associated with this component.
`void`	`addPosImpulse(double[] xbuf, int xidx, double h, double[] vbuf, int vidx)`
`void`	`addSolveBlock(SparseNumberedBlockMatrix S)`
`void`	`applyExternalForces()`
`void`	`applyGravity(Vector3d gacc)` Applies a gravity force to this component, given a prescribed gravity acceleration vector.
`MatrixBlock`	`createMassBlock()` Create a matrix block for representing the mass of this component, initialized to the component's effective mass (instrinsic mass plus the mass due to all attachmented components).
`DynamicAttachment`	`getAttachment()` Returns the slave attachment associated with this component, if any.
`java.util.List<Constrainer>`	`getConstrainers()` Returns a list of Constrainers associated with this component.
`double`	`getEffectiveMass()` Gets the effective scalar mass of this component.
`void`	`getEffectiveMass(Matrix M, double t)` Gets the effective mass of this component at a particular time.
`int`	`getEffectiveMassForces(VectorNd f, double t, int idx)` Gets the mass forces for this component at a particular time.
`int`	`getForce(double[] buf, int idx)`
`void`	`getInverseMass(Matrix Minv, Matrix M)` Inverts a mass for this component.
`double`	`getMass(double t)` Returns the scalar mass of this component at time t.
`void`	`getMass(Matrix M, double t)` Gets the mass of this component at a particular time.
`java.util.LinkedList<DynamicAttachment>`	`getMasterAttachments()` Returns a list of the attachments for which this component is a master, or null if there are no such attachments.
`int`	`getPosDerivative(double[] buf, int idx)`
`int`	`getPosState(double[] buf, int idx)`
`int`	`getPosStateSize()`
`int`	`getSolveIndex()`
`void`	`getState(DataBuffer data)` Saves state information for this component by adding data to the supplied DataBuffer.
`int`	`getVelState(double[] buf, int idx)`
`int`	`getVelStateSize()`
`boolean`	`hasForce()` Queries whether or not this component actually exerts its own state-dependent forces (typically associated with damping).
`boolean`	`isActive()` Returns true if this component is active.
`boolean`	`isAttached()` Returns true if this component is attached.
`boolean`	`isControllable()` Returns true is this component is active, or it is attached to one or more other components which ultimately are attached to at least one active component.
`boolean`	`isDynamic()` Returns true if this component is dynamic.
`boolean`	`isMassConstant()`
`boolean`	`isParametric()` Returns true if the state of this component is determined parametrically; i.e., it is neither dynamic nor attached.
`int`	`mulInverseEffectiveMass(Matrix M, double[] a, double[] f, int idx)`
`boolean`	`removeConstrainer(Constrainer c)` Removes a Constrainer from the list returned by `getConstrainers()`.
`void`	`removeMasterAttachment(DynamicAttachment a)` Removes a DynamicAttachment from the list of master attachments associated with this component.
`void`	`resetEffectiveMass()` Resets the effective mass of this component to the nominal mass.
`void`	`setAttached(DynamicAttachment attachment)` Attach this component to another via a DynamicAttachment object.
`int`	`setForce(double[] buf, int idx)`
`int`	`setPosState(double[] buf, int idx)`
`void`	`setRandomForce()` Sets the force of this component to a random value.
`void`	`setRandomPosState()` Sets the position state of this component to a random value.
`void`	`setRandomVelState()` Sets the velocity state of this component to a random value.
`void`	`setSolveIndex(int idx)`
`void`	`setState(DataBuffer data)` Restores the state for this component by reading from the supplied data buffer, starting at the current buffer offsets.
`int`	`setVelState(double[] buf, int idx)`
`boolean`	`velocityLimitExceeded(double tlimit, double rlimit)` Checks if the current component velocity exceeds specified limits.
`void`	`zeroExternalForces()`
`void`	`zeroForces()`

Methods inherited from interface artisynth.core.modelbase.HasNumericState
advanceState, getAuxVarDerivative, getAuxVarState, getStateVersion, hasState, numAuxVars, requiresAdvance, setAuxVarState

- Method Detail
  - getAttachment
```
DynamicAttachment getAttachment()
```
    Returns the slave attachment associated with this component, if any.
    
    Returns:
    
    slave attachment, or null if the component is unattached
  - getMasterAttachments
```
java.util.LinkedList<DynamicAttachment> getMasterAttachments()
```
    Returns a list of the attachments for which this component is a master, or null if there are no such attachments. The returned list must not be modified.
    
    Returns:
    
    list of master attachments
  - setAttached
```
void setAttached(DynamicAttachment attachment)
```
    Attach this component to another via a DynamicAttachment object. This method is intended for internal use by attachment components.
    
    Parameters:
    
    attachment - Specifies the attachment relationship between this component and its master(s)
  - addMasterAttachment
```
void addMasterAttachment(DynamicAttachment a)
```
    Add a DynamicAttachment to the list of master attachments associated with this component. This method is intended for internal use by attachment components.
    
    Parameters:
    
    a - master attachment to add
  - removeMasterAttachment
```
void removeMasterAttachment(DynamicAttachment a)
```
    Removes a DynamicAttachment from the list of master attachments associated with this component. This method is intended for internal use by attachment components.
    
    Parameters:
    
    a - master attachment to remove
  - getConstrainers
```
java.util.List<Constrainer> getConstrainers()
```
    Returns a list of Constrainers associated with this component. This list is not necessarily complete; it is up to Constrainer objects themselves to decide whether to add themselves to this list. Constrainers which are in the list can be notified when aspects of this component change in a way that requires the attention of the Constrainer. For example, calling transformGeometry() on this component may require some of its constrainers to be updated.
    
    Returns:
    
    list of Constrainers associated with this component.
  - addConstrainer
```
void addConstrainer(Constrainer c)
```
    Adds a Constrainer to the list returned by getConstrainers(). This method is intended for internal use by the Constrainer components themselves.
    
    Parameters:
    
    c - Constrainer to add the constrainer list.
  - removeConstrainer
```
boolean removeConstrainer(Constrainer c)
```
    Removes a Constrainer from the list returned by getConstrainers(). This method is intended for internal use by the Constrainer components themselves.
    
    Parameters:
    
    c - Constrainer to remove from the constrainer list.
    
    Returns:
    
    true if the constrainer was present in the list.
  - isDynamic
```
boolean isDynamic()
```
    Returns true if this component is dynamic. If a component is unattached, then its state is determined by forces if it is dynamic, or parametrically if it is non-dynamic.
    
    Returns:
    
    true if this component is dynamic
  - isActive
```
boolean isActive()
```
    Returns true if this component is active. A component is active if its position and velocity are determined by forces, which implies that it is dynamic and unattached.
    
    Returns:
    
    true if this component is active
  - isAttached
```
boolean isAttached()
```
    Returns true if this component is attached. The state of an attached component is derived from the state of an attached master component.
    
    Returns:
    
    true if this component is attached
  - isParametric
```
boolean isParametric()
```
    Returns true if the state of this component is determined parametrically; i.e., it is neither dynamic nor attached.
    
    Returns:
    
    true if this component's state is determined parametrically.
  - isControllable
```
boolean isControllable()
```
    Returns true is this component is active, or it is attached to one or more other components which ultimately are attached to at least one active component.
    
    Returns:
    
    true if this component is controllable.
  - getSolveIndex
```
int getSolveIndex()
```
  - setSolveIndex
```
void setSolveIndex(int idx)
```
  - createMassBlock
```
MatrixBlock createMassBlock()
```
    Create a matrix block for representing the mass of this component, initialized to the component's effective mass (instrinsic mass plus the mass due to all attachmented components).
  - isMassConstant
```
boolean isMassConstant()
```
  - getMass
```
double getMass(double t)
```
    Returns the scalar mass of this component at time t.
  - getMass
```
void getMass(Matrix M,
             double t)
```
    Gets the mass of this component at a particular time. Not currently used; getEffectiveMass() is used instead.
    
    Parameters:
    
    M - matrix to return the mass in
    
    t - current time
  - getEffectiveMassForces
```
int getEffectiveMassForces(VectorNd f,
                           double t,
                           int idx)
```
    Gets the mass forces for this component at a particular time. The forces should be stored in f, starting at the location specified by idx. Upon return, this method should return the value of idx incremented by the dimension of the mass forces.
    
    Parameters:
    
    f - vector to return the forces in
    
    t - current time
    
    idx - starting location within f where forces should be stored
    
    Returns:
    
    updated value for idx
  - getInverseMass
```
void getInverseMass(Matrix Minv,
                    Matrix M)
```
    Inverts a mass for this component.
    
    Parameters:
    
    Minv - matrix to return the inverse mass in
    
    M - matrix containing the mass to be inverted
  - resetEffectiveMass
```
void resetEffectiveMass()
```
    Resets the effective mass of this component to the nominal mass.
  - getEffectiveMass
```
void getEffectiveMass(Matrix M,
                      double t)
```
    Gets the effective mass of this component at a particular time. The effective mass is the nominal mass plus any additional mass incurred from attached components.
    
    Parameters:
    
    M - matrix to return the mass in
    
    t - current time
  - getEffectiveMass
```
double getEffectiveMass()
```
    Gets the effective scalar mass of this component. The effective mass is the nominal mass plus any additional mass incurred from attached components.
    
    Returns:
    
    effective scalar mass
  - mulInverseEffectiveMass
```
int mulInverseEffectiveMass(Matrix M,
                            double[] a,
                            double[] f,
                            int idx)
```
  - addSolveBlock
```
void addSolveBlock(SparseNumberedBlockMatrix S)
```
  - addPosImpulse
```
void addPosImpulse(double[] xbuf,
                   int xidx,
                   double h,
                   double[] vbuf,
                   int vidx)
```
  - getPosDerivative
```
int getPosDerivative(double[] buf,
                     int idx)
```
  - getPosState
```
int getPosState(double[] buf,
                int idx)
```
  - setPosState
```
int setPosState(double[] buf,
                int idx)
```
  - getVelState
```
int getVelState(double[] buf,
                int idx)
```
  - setVelState
```
int setVelState(double[] buf,
                int idx)
```
  - setForce
```
int setForce(double[] buf,
             int idx)
```
  - addForce
```
int addForce(double[] buf,
             int idx)
```
  - getForce
```
int getForce(double[] buf,
             int idx)
```
  - getPosStateSize
```
int getPosStateSize()
```
  - getVelStateSize
```
int getVelStateSize()
```
  - zeroForces
```
void zeroForces()
```
  - zeroExternalForces
```
void zeroExternalForces()
```
  - applyExternalForces
```
void applyExternalForces()
```
  - velocityLimitExceeded
```
boolean velocityLimitExceeded(double tlimit,
                              double rlimit)
```
    Checks if the current component velocity exceeds specified limits. Used to check solution stability.
    
    Parameters:
    
    tlimit - translational velocity limit
    
    rlimit - rotational velocity limit
    
    Returns:
    
    true if velocity exceeds specified limits
  - applyGravity
```
void applyGravity(Vector3d gacc)
```
    Applies a gravity force to this component, given a prescribed gravity acceleration vector.
  - setRandomPosState
```
void setRandomPosState()
```
    Sets the position state of this component to a random value. Used for testing.
  - setRandomVelState
```
void setRandomVelState()
```
    Sets the velocity state of this component to a random value. Used for testing.
  - setRandomForce
```
void setRandomForce()
```
    Sets the force of this component to a random value. Used for testing.
  - hasForce
```
boolean hasForce()
```
    Queries whether or not this component actually exerts its own state-dependent forces (typically associated with damping). If it does not, then the component makes no contribution to its stiffness and damping matrices, a fact that can be exploited to improve the efficiency of the physics solve.
    Any action that alters the return value of this method should propagate a StructureChangeEvent. This can be a state-not-changed event if component's state structure is not altered (which it typically won't be).
    
    Returns:
    
    true if this component exerts its own forces.
  - getState
```
void getState(DataBuffer data)
```
    Description copied from interface: HasNumericState
    
    Saves state information for this component by adding data to the supplied DataBuffer. Existing data in the buffer should not be disturbed.
    
    Specified by:
    
    getState in interface HasNumericState
    
    Parameters:
    
    data - buffer for storing the state values.
  - setState
```
void setState(DataBuffer data)
```
    Description copied from interface: HasNumericState
    
    Restores the state for this component by reading from the supplied data buffer, starting at the current buffer offsets.
    
    Specified by:
    
    setState in interface HasNumericState
    
    Parameters:
    
    data - buffer containing the state information

Interface DynamicAgent

Method Summary

Methods inherited from interface artisynth.core.modelbase.HasNumericState

Method Detail

getAttachment

getMasterAttachments

setAttached

addMasterAttachment

removeMasterAttachment

getConstrainers

addConstrainer

removeConstrainer

isDynamic

isActive

isAttached

isParametric

isControllable

getSolveIndex

setSolveIndex

createMassBlock

isMassConstant

getMass

getMass

getEffectiveMassForces

getInverseMass

resetEffectiveMass

getEffectiveMass

getEffectiveMass

mulInverseEffectiveMass

addSolveBlock

addPosImpulse

getPosDerivative

getPosState

setPosState

getVelState

setVelState

setForce

addForce

getForce

getPosStateSize

getVelStateSize

zeroForces

zeroExternalForces

applyExternalForces

velocityLimitExceeded

applyGravity

setRandomPosState

setRandomVelState

setRandomForce

hasForce

getState

setState