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.

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.

Endpoint requirements#

The simplification feature imposes some restrictions on the rigging string node in terms of its route and endpoints.

A rigging string node can only be constructed between two circles or groups of circles. These groups are called Upper and Lower. To enable linearization it is required that:

  1. All circles in the upper and lower groups share a common ancestor

  2. The nearest common ancestor of the upper group is not the same as the nearest common ancestor of the lower group.

  3. For linearization only: 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.

Note that the requirements are only checked when creating the node or when switching to simplified representation.

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 quite 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.

  • The routing of slings and grommet (the reversed property for connections) can not be edited. Slings and grommets will automatically be created using the shortest route.

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 fixedimage-20231112211722671

Child free: image-20231112211937295

Parent free: image-20231112212111872

parent and child free: image-20231112212035653

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.

The button to add a rigging-string does not appear in the GUI:

  • Make sure that two groups of circles with difference common ancestors are selected. Selecting only circles on the same item will not work.

I have a model with a simplified rigging string, when trying to load it I get an error Going to simple representation failed on xxx . What is going on?

  • The requirements for simplification are checked when creating the rigging string and when switching from full to simplified model. The rigging string does not observe the model to continuously check if all the conditions are met. This means that it is possible to modify the model such that linearization is no longer after the rigging string has been created and linearized. In this case the model can still be saved but loading the model will result in an error. If this happens then remove the line r.full_representation = False for the affected node from the .dave file. That may help.

  • If the invalid linearized model is really what you wanted, then dissolve the riggingstring node after linearization.

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.

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)