3.2.5.1 Load-Case-Combinator
Last updated
Last updated
The "Load-Case-Combinator"-component takes a list of strings which contain combination rules and transforms them into load-combinations (see Fig. 3.2.5.1). The names are expanded until no further substitution is possible.
The "Load"-output consists of a "Load-Combinations"-object which (along with others) can be plugged into the "Load"-input of the "Assemble"-component on model setup. Its text representation lets the user check whether the expanded rules conform what is intended. The load-combinations are listed alphabetically by their names.
A load-case-combinations object may contain several combinations whose names get output at the "Names" output-plug. For each of these the "Nums"-output delivers the number of load-cases contained in each load-case-combination.
A quick guide to the syntax involved in formulating load case combinations shows up when one lets the mouse-pointer hover over the 'Rules'-input. Here the long version:
Combination rules consist of a combination's name on the left-hand side and equals sign and a combination expression.
If a combination name shows up multiple times on the left-hand side, the corresponding expressions are combined via an OR-relation.
Spaces may be introduced for better readability but do not have any effect.
Everything that follows "#" is a comment (see fig. 3.2.5.1).
Lines may be empty (see fig. 3.2.5.1.4)
Combination expressions on the right-hand side of a rule consist of a series of load-case- or load-combination-names. Each of these may be prefixed by a factor.
Combination names and references to these may occur in any order. In fig. 3.2.5.1.4 "s" could have been defined after "ULS". Circular references lead to an error message.
A factor in front of a name may be a number or an expression which consists of braces and two numbers separated by "|". The latter symbolizes a factor which can be the first or the second number. This allows to express variable loads via "(0|number) * name" (see fig. 3.2.5.1.2). In the context of combination via '&' the first number plays the role of the upper limit; the second number sets the lower limit.
Expressions get evaluated from left to right. The factored names can be linked via these operators listed in ascending priority:
"|" corresponds to "or".
"+" and "-" symbolize addition and subtraction.
"&" combines terms using permutated leading factors (see fig. 3.2.5.1.3). The numbers in front of a name are interpreted as upper and lower limits. In case of factors with only one number it is assumed to be the upper and lower value. In each resulting load-case one of the terms enters first with its upper value, the others join the load-case with their lower value as multiplication factor.
Braces "(" and ")" can be used to override the default priority of operators (see fig. 3.2.5.1.4).
On the right-hand side of a combination expression simplified regular expressions may be used. They end with "$" or "*" and match all names that are identical up to the "$" or "*" respectively. So "wind$" matches for example "windNorth" and "windSouth" but not "wWest". All items that match get combined in an OR-relation.
Simplified regular expressions either match names of load-cases or load-case-combinations. The latter take precedence over the former. Since load-case names are only known at the time of model assembly the matching of simplified regular expressions for load-case names takes place at that stage.
The application of simplified regular expressions allows to categorize actions via their names and to formulate generally applicable combinations rules. In fig. 3.2.5.1.5 the load-cases "w11", "w22", "s11" and "s22" play the role of load-cases that could have been supplied via load-components. "w" and "s" use regular expressions to catch all load-cases that start with "w" and "s".
In case input lines 0 to 3 would be missing in Fig. 3.2.5.1.5. the output on the left side would contain "w$" and "s$" and their resolution into load-case names would be postponed to the model assembly stage.
