Rigging string node

Rigging string node#

A Rigging String is a set of slings, grommets and shackle tied together. It can be used to connect two objects: For example a crane-hook to a rigging beam or a set of padeyes to a grommet protector.

A rigging string node can only be constructed between two circles or groups of circles. These groups are called Upper and Lower.

The unique feature of rigging string nodes is that the whole set can be linearized and replaced with a single linear spring and weight. This is useful if the model needs to be simplified, for example for export to time-domain or FEM.

Even if simplification is not needed, the rigging string node can still be used because it provides a convenient way to define the connections between slings, grommets and shackles.

The rigging string node provides and alternative to defining slings, shackles and grommets individually. Which method to use is a matter of personal preference.

Switching from a rigging string node to individual components can be done by dissolving the rigging string. The other way around is not possible.

The intended use of the simplified mode is for export. Keeping the rigging string in simple mode while working with the model is not recommended as the correct linearization may change if the model changes.

What does a circle represent#

If a grommet or sling is connected to a circle then the circle is treated as solid. For example a trunnion or the pin or bow of a shackle. If a shackle is connected to a circle then it is treated as a hole that the shackle is inserted into. For example the hole of a padeye.

Limitations#

The Rigging-string node has a few limitations and restrictions. If you run into them and you do not need the linearization feature then don’t hesitate do dissolve the node.

Limitations are:

Grommets are only supported “line” mode. Grommets in circle mode are not supported. This means that some configurations can not be made.
Friction can not be edited
Maximum winding angles can not be edited
The endpoint requirements listed above. Basically this means the rigging string connects two objects.

Linearization#

During linearization the rigging string is suspended vertically between two frames. The upper frame is fixed while the lower frame can move vertically. Two forces are added (in turn) to the lower frame:

\(F_{low}\) = the largest of (1/3)th of the highest MBL and 100/3
\(F_{high}\) = \(2 \times F_{low}\)

The linearized properties are derived from the displacements of the lower frame in these two situations.

The weight can be derived from the difference between the force on the upper frame and the lower frame.

Endpoint requirements for simplified model#

To enable linearization it is required that:

All circles in the upper and lower groups share a common ancestor
The nearest common ancestor of the upper group is not the same as the nearest common ancestor of the lower group.
All circles are rigidly fixed to their common parent.

Practically this mean that both groups need to be located on different items. For example the upper group on a lifting-beam and the lower group on the lifted item.

If these requirements are not met, then trying to switch to simplified will fail and will produce a warning. In that case the model will remain in full mode.

If the model is changed such that the requirements are not met AFTER going linearized mode then the linearized model is invalid. In that case:

A warning will be shown.
If the node will return to its full representation if
- saved and opened
- copied
- the undo function of the GUI is used

Settings#

The representation of a rigging string can be set to either “Full” or “Simplified”. Setting the representation of the model to “simplified” will include the linearized model in the scene instead of the full model. This can be very useful when exporting to time-domain simulators. For rigging analysis “full” should normally be used.

Note: simplified models are not included in a rigging analysis

Degrees of freedom for shackle-to-shackle connections#

Shackle to shackle connections are created using geometric connection nodes using the “outside contact” model.

By default all the degrees of freedom in these connections are frozen to the inline position. This means that the shackles fixed together in a line. For rigging systems where the rigging is taut this is typically good enough. If it is not, then parent, child or both rotations can be set to free.

Default: Parent and child fixed	Child free:
Parent free:	parent and child free:

So why not always set all to free? Because it may cause convergence issues when the shackle rotate out of each-other. The solver will check for that and will adjust the model and restart the solver when an invalid end-state is encountered. But sometimes that just doesn’t work out resulting the the solver getting stuck in a loop:

Known questions and answers#

The system is twisted:

The directions in which a sling or grommet runs over the connections is determined based on the shortest route. This is for the geometry that the model is in at the moment that the rigging string is defined. If the geometry changes significantly afterwards the selected optimum route may not be the best anymore. If this happens then click the “update” button or temporary change something in the rigging system as that will trigger re-calculation.

I can not change ….. :

Some of the properties are automatically determined and can not be changed. Solution: dissolve (explode) the rigging-string and edit the sling/grommets directly.

I have a model with a simplified rigging string, when trying to load it returns to full mode instead

The requirements for simplification are checked when creating the rigging string and when switching from full to simplified model. If the conditions are not met when saving the model then do linearization will not be executed when loading the model again and the string will remain in full mode.
If the invalid linearized model is really what you wanted, then dissolve the riggingstring node after linearization.

Demo Scene to play with#

# Upper and point
s.new_frame(name='Common_parent_upper', position = (0,0,10))
s.new_point(name='Point',
          parent='Common_parent_upper')

# Lower with two points
s.new_rigidbody(name='Common_parent_lower',
                mass=1000,
                cog=(0,0,-2),
          fixed =(False, False, False, True, True, True))

s.new_point(name='Point2',
          parent='Common_parent_lower',
          position=(3,0, 0))

s.new_point(name='Point3',
          parent='Common_parent_lower',
          position=(-3,0,0))

# Add circles to all points
for p in s.nodes_of_type(Point):
    s.new_circle(s.available_name_like('Circle'), parent = p, axis=(0,1,0), radius=1)