When working with subject specific scaling of models, it can be a valuable tool to know what the strength of your model is for a given posture. With strength we mean the maximum permissible load that the model can carry in a given posture. This post will show you a way of calculating the maximum strength of a simple 2D arm model in various postures. The concepts presented can of course be extended to models involving the full body model or parts of it.

For us to do so, we first need to setup an example model. The model is a 2D arm model comprised of an upper and lower arm segment, attached with 8 simple muscles (fig. 1). The model is constraint to only allow movement in the global x and y direction. This allows us to impose movements which resembles flexion and extension of the shoulder and elbow joint. Further, we want to show a general way of calculating the strength independent of the movement, we therefore set up four load scenarios to mimic a flexion, extension, push, and pull movement.

Since we want to investigate *maximum strength*, we need to be sure that the
muscles are recruited appropriately. This is done by switching to the
`MinMax_Strict`

muscle recruiter in the study section of our model. For more
information on muscle recruitment in the Anybody Modelling software, se this
tutorial.

The first step in finding the default maximum strength for a posture, is to know
the relationship between load and `MaxMuscleActivity`

( $m_{act}$ ). We
can do this by implementing a parameter study to investigate the $mmact$ across
a spectrum of loads. This is done using the `AnyParamStudy`

class as seen below:

This study runs our model through the loads defined in the $load$ variable. So, in this example it does 100 steps where it starts at 0 N and stops at 250 N. This enables us to plot the $m_{act}$ as a function of the load. By running the parameter study for all four load scenarios we end up with a graph as seen in fig. 2.

We can see that for very low loads there might be other factors than the applied load affecting the relationship. If we dwell by this fact and wonder why this could be, we could infer that the influence of gravity and segment mass could interfere with the relationship between $load$ and $m_{act}$. This means that when applying low external loads, the important factor in $m_{act}$ is the mass of the moved segments, and the gravity imposed on those segments.

The graphs on fig. 2 also tells us that for high loads there is a linear relationship between load and $m_{act}$, and the linear part is crossing $m_{act} = 1$ for all scenarios. We can use this information to calculate the maximum strength of the model. If we look at the equation for a linear function it looks like this:

Where $a$ is the slope of the function, and $b$ is the intercept with the y-axis. The slope of the linear part can be calculated using only two points and applying the equation:

Now that we know the coordinates of two points and the slope, we can start figuring out what the load is for an activity of 1 ( $m_{act} = 1$ ). For this we again look at equation $\ref{eq:2}$, only this time we know the slope, the point $(load_{1},m_{act_{1}})$, and the $m_{act}$ coordinate, which should be equal to 1. We are therefore interested in finding the corresponding $load_{max}$. We rearrange equation $\ref{eq:2}$, into:

This allows us to evaluate what the maximum load $load_{max}$ is, that the model can support for a given posture. To check our results, we can calculate the maximum strength for our four scenarios using equation $\ref{eq:3}$ and try to implement the output load in our models. Table 1. shows the calculated strengths of the models, and the $m_{act}$ when applying the $load_{max}$ values.

Movement | $Load_{max}$ (N) | New $m_{act}$ |
---|---|---|

Extension | 70.97891372 | 1.0 |

Flexion | 78.33099967 | 1.0 |

Push | 93.43104145 | 1.0 |

Pull | 113.1664796 | 1.0 |

Table 1: Calculated $load_{max}$ and new $m_{act}$ for each movement.

Now we can calculate the maximum load for any given posture!

### Find the code on GitHub

The AnyScript example which shows the concept of finding the maximum strength is available on GitHub.