DynamicAttachment (Artisynth API documentation)

All Known Subinterfaces:

DynamicAttachmentComp

All Known Implementing Classes:

DirectorFem3dAttachment, DirectorFrameAttachment, DynamicAttachmentBase, FrameAttachment, FrameFem3dAttachment, FrameFrameAttachment, FrameNodeNodeAttachment, NodeFrameNodeAttachment, PointAttachment, PointFem3dAttachment, PointFrameAttachment, PointParticleAttachment, PointSkinAttachment, ShellNodeFem3dAttachment, ShellNodeFrameAttachment
```
public interface DynamicAttachment
```
Object that implements attachment between dynamic components. A component 'a' can be attached to one or more "master" components 'b' if it's position q_a can be made an explicit differentiable function of the positions q_m of the masters:
```
 q_a = f (q_m)
 
```
Differentiating means that the attached component velocity u_a is a linear function of the master velocities u_m:
```
 u_a = -G (u_m)
 
```
where G = -(d f)/(d q_m) is the "constraint matrix".

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`addBackRefs()` Every master component should contain a back reference to each attachment that references it.
`void`	`addMassToMasters()`
`void`	`applyForces()`
`boolean`	`getDerivative(double[] buf, int idx)`
`MatrixBlock`	`getGT(int idx)` Returns the transpose of the constraint matrix G associated with the idx-th master component.
`DynamicComponent[]`	`getMasters()`
`DynamicComponent`	`getSlave()` Returns the slave DynamicMechComponent associated with this attachment.
`void`	`invalidateMasters()`
`void`	`mulSubGT(double[] ybuf, int yoff, double[] xbuf, int xoff, int idx)` Computes
`void`	`mulSubGTM(MatrixBlock D, MatrixBlock M, int idx)` Computes
`void`	`mulSubMG(MatrixBlock D, MatrixBlock M, int idx)` Computes
`int`	`numMasters()`
`void`	`removeBackRefs()` Removes the back reference to this attachment's slave component from each of the master component.
`void`	`setSlaveAffectsStiffness(boolean affects)`
`boolean`	`slaveAffectsStiffness()`
`void`	`updateAttachment()` Update attachment to reflect changes in the slave state.
`void`	`updatePosStates()`
`void`	`updateVelStates()`

- Method Detail
  - getMasters
```
DynamicComponent[] getMasters()
```
  - numMasters
```
int numMasters()
```
  - invalidateMasters
```
void invalidateMasters()
```
  - getSlave
```
DynamicComponent getSlave()
```
    Returns the slave DynamicMechComponent associated with this attachment. In some cases, the attachment may connect some other entity (such as a mesh vertex) to the master components, in which case this method should return null.
    
    Returns:
    
    slave DynamicMechComponent, if any
  - slaveAffectsStiffness
```
boolean slaveAffectsStiffness()
```
  - setSlaveAffectsStiffness
```
void setSlaveAffectsStiffness(boolean affects)
```
  - addBackRefs
```
void addBackRefs()
```
    Every master component should contain a back reference to each attachment that references it. This method adds the back reference for this attachment to each of the masters.
  - removeBackRefs
```
void removeBackRefs()
```
    Removes the back reference to this attachment's slave component from each of the master component.
  - updatePosStates
```
void updatePosStates()
```
  - updateVelStates
```
void updateVelStates()
```
  - updateAttachment
```
void updateAttachment()
```
    Update attachment to reflect changes in the slave state.
  - applyForces
```
void applyForces()
```
  - addMassToMasters
```
void addMassToMasters()
```
  - getDerivative
```
boolean getDerivative(double[] buf,
                      int idx)
```
  - mulSubGTM
```
void mulSubGTM(MatrixBlock D,
               MatrixBlock M,
               int idx)
```
    Computes
```
       T
 D -= G  M
 
```
    where D and M are matrices associated with master and slave components, respectively, and G is the constraint matrix for the attachment.
    Parameters:
    
    D - dependent matrix associated with a master component
    
    M - matrix associated with a slave component
  - mulSubMG
```
void mulSubMG(MatrixBlock D,
              MatrixBlock M,
              int idx)
```
    Computes
```
 D -= M G
 
```
    where D and M are matrices associated with master and slave components, respectively, and G is the constraint matrix for the attachment.
    Parameters:
    
    D - dependent matrix associated with a master component
    
    M - matrix associated with a slave component
  - getGT
```
MatrixBlock getGT(int idx)
```
    Returns the transpose of the constraint matrix G associated with the idx-th master component.
    
    Parameters:
    
    idx - index of the master component
    
    Returns:
    
    transpose of G associated with idx
  - mulSubGT
```
void mulSubGT(double[] ybuf,
              int yoff,
              double[] xbuf,
              int xoff,
              int idx)
```
    Computes
```
       T
 y -= G  x
 
```
    where y and x are vectors associated with master and slave components, respectively, and G is the constraint matrix for the attachment.
    Parameters:
    
    ybuf - buffer into which to store result
    
    yoff - offset into ybuf
    
    xbuf - buffer containing right hand side vector
    
    xoff - offset into xbuf
    
    idx - master component index

Interface DynamicAttachment

Method Summary

Method Detail

getMasters

numMasters

invalidateMasters

getSlave

slaveAffectsStiffness

setSlaveAffectsStiffness

addBackRefs

removeBackRefs

updatePosStates

updateVelStates

updateAttachment

applyForces

addMassToMasters

getDerivative

mulSubGTM

mulSubMG

getGT

mulSubGT