# Generating loadcases for friction#

DAVE is able to work with friction forces defined at cable, sling or grommet connections. But which combination of friction forces results in the governing result?

This section dives into that subject and shows how the loadcases are generated.

For friction see: Cable

For global friction effects see: Global friction effects

## Slings#

For slings it is assumed that the extreme loads on the model occur with extreme frictions. For the example model this is easily verified to be the case (figure below). The highest and lowest load on the shackle coincide with the extreme values of friction (-0.1 and + 0.1):

Furthermore it is assumed that if a certain quantity increases due to a friction at some connection, then it will decrease if the friction acts in the opposite direction.

With these two assumptions, friction on connections of slings can be incorporated in the analysis in the same way as all the other variations.

## Grommets / Loops#

For grommets or loops the situation is more complex. Because the loop is closed, the friction forces along the entire length need to add up to zero. This means that not all combinations are possible. For example the situation sketched below, where maximum friction in the same direction is applied at three of the four points, would result in an exceedance of the friction at the fourth.

### So how to determine the governing combination(s) ?#

The amount of possible combinations is unlimited which is not practical. To bring back the amount of load-cases to a manageable amount the following rules are applied:

The friction at one or more of the connections is at its extreme

The absolute friction factors at the other connections are identical

For the current example this brings back the number of load-cases to 32 (\(=2^{n+1}\) with n is the number of friction forces).

#### Worked Example#

The 32 load-cases are created and run for the current model. The load-case resulting in the highest load on the shackle is shown below:

The friction forces (-51, -42, 57 and 36) add up to zero.

The results of all load-cases are shown in the table below.

The first four columns are the friction factors at the four connection points of the grommet. The fifth shows the resulting load in the shackle. The results are ordered from high to low.

## Further proof#

So did we find *the* maximum?

This is an optimization problem with *three* unknowns. This is one less than the number of connections because the total *friction* needs to add up to 0. (Note that this applies to the friction in kN which is calculated from the friction factor, the tension in the line and the angle of the connection. The friction *factors* as shown in the table do not have to add up to 0).

The above means that the first four columns are interdependent. Setting three of them dictates the fourth. The load-cases resulting in the highest load is shown on the top row. The three rows below that are three possible small variations of that load-case. There three variations represent steps in the three possible degrees of freedom along the edge of the domain. As all three result in a lower load we can conclude that __we have found a local maximum__ (purely mathematical it is still possible that a smaller variation would result in a higher load, but considering the physics of the model this is not the case).

The next question is whether or not this local maximum is also the global maximum in the domain. This is the case when all the local maxima are in the load-cases. This is done by comparing the results of the algorithm to those of a brute-force approach.

The following animation shows the results of the brute-force approach (in the rainbow colors) as well as the points evaluated earlier (black triangles). It illustrates the absence of interior maxima.

Increasing the grid to 25 equally distributed points along the three free axes (15.625 grid-points in total) does not reveal any other maxima than the ones already evaluated. So for this case we did indeed find the global maximum.

## Generic case#

In the general case it can not be guaranteed that the global maximum is one of the picked cases without considering the physics, and the physics depend on the model which is made by the user. All we can do is demonstrate that, for a number of typical cases, the algorithm does indeed find the global maximum.

A few cases with 2 or 3 degrees of freedom are shown in the following section.

### Cases with 2 or 3 circles can still be visualized#

### Requested examples#

In the following case, does to algorithm correctly determine the case that results in the maximum vertical load on the bottom circle? Especially because for the optimum that friction needs to be 0.

and also for this case:

## Summary and Conclusion#

Friction on cables can be fully included including its effect on the geometry.

For cables forming loops, such as grommets, it is not trivial to find the governing combination of friction forces because the total amount of friction over the loop needs to add up to zero. An algorithm is included that limits the amount of evaluations to a practical number. This should be more than sufficient for most of the simple and complex rigging configurations.

It is noted that this algorithm is not guaranteed to find the governing case for *any* possible configuration. If loops are used in a non-standard way and friction has a large influence, then the applicability of the loadcases (as well as the rigging design itself!) should be carefully evaluated. In such a case you are likely dealing with a special situation which is something that DAVE is good at but may be troublesome to perform in reality.

## Reproduce#

The following DAVE / python code reproduces the model above.

```
point = s.new_point(name="Point")
s.new_circle(name="Circle", parent=point, axis=(0, 1, 0), radius=0.4)
s.new_rigidbody(
name="Body",
fixed=(False, True, False, True, False, True),
mass=100,
cog=(0, 0, -3.5),
)
point = s.new_point(name="Point2", parent="Body", position=(-5.0, 0.0, 0.0))
s.new_circle(name="Circle2", parent=point, axis=(0, 1, 0), radius=0.2)
s.new_shackle(name="Shackle", kind="WB300")
s["Shackle"].parent = "Body"
s["Shackle"].position = (5.0, 0.0, 0.0)
s["Shackle"].fixed = (True, True, True, True, False, True)
s.new_visual(name="Visual", parent="Body", path="res: cube_with_bevel.obj")
s["Visual"].scale = (6.0, 1.0, 3.0)
s["Visual"].offset = (0.0, 0.0, -3.2)
SlingGrommet(
s,
s.available_name_like("sling_grommet"),
connections=("Circle2", "Circle", "Shackle/bow"),
)
s["sling_grommet"].mode = SlingGrommetMode.LINE
s["sling_grommet"].length = 20.0
s["Shackle"].watches["Load"] = Watch(
evaluate="self.load / s.g", condition="", decimals=3
)
# to enable friction, un-comment the following line:
# s['sling_grommet'].friction = [None, -0.1, 0.0]
```