Loads¶

Every load belongs to a load case. Create the case, then put loads in it. Magnitudes are positive numbers; the direction gives the sign. The bar, node, region and case can each be given as the object a create_* call returned or as its id as text ('B1', 'N2', 'G'): the objects only exist in the reply that made them, the ids always do.

The same calls add a load to a model that already has some: nothing that is there changes. A load on a bar that is already loaded in that case adds to it.

Load	Call	Unit
uniform, on a bar	`create_uniform_load(bar, case, value, 'down')`	kN/m
trapezoidal, on a bar	`create_bar_distributed_load(bar, case, q_i=, q_j=)`	kN/m
point load along a bar	`create_bar_point_load(bar, case, p, at=0.5)`	kN, `at` is the fraction of the span
point load on a node	`create_node_load(node, case, p, 'down')`	kN
pressure on a slab or wall region	`create_uniform_load(region, case, value, 'down')`	kN/m²
self weight	`load_case` option or `create_self_weight(factor, case)`
temperature	`create_temperature(bar, uniform=, gradient=, load_case=)`	degrees
settlement of a support	`create_support_settlement(node, case, uy=)`	m

There is no call to edit a load in place: to change one, delete it and create it again (delete_load). The headings below are one type of load each, with Add, Edit and Remove.

Load cases¶

Load case: add¶

A case has an id and, optionally, a type: 'permanent' (the default), 'live', 'wind', 'seismic' or 'temperature':

model.create_load_case('HLOAD', action_type='wind')
model.create_load_case('SW', self_weight_factor=1.0)      # a case that carries the self weight

A linear analysis case with the same name is created with it.

Load case: edit¶

Change a load case: rename it.

model.rename_load_case('G', 'Permanent')

Load case: remove¶

Delete a load case (with the loads in it):

model.remove_load_case('Q')

Loads on nodes¶

Node load: add¶

model.create_node_load('N2', 'G', 20, 'down')                 # 20 kN
model.create_node_load('N2', 'G', 5, 'right')                 # 'left' / 'right' are horizontal

Node load: edit¶

Change a nodal load: remove it and create it again with the changed value.

model.delete_load('N2', 'G')                                  # what N2 carries in case G
model.create_node_load('N2', 'G', 25, 'down')                 # the new value

Node load: remove¶

Delete the loads on a node:

model.delete_load('N2', 'G')          # one case; '' (or no case) for every case

Loads on bars¶

Line load: add a uniform load¶

model.create_load_case('G')                         # permanent actions
model.create_uniform_load('B1', 'G', 10, 'down')    # 10 kN/m on bar B1, gravity

direction is 'down' or 'up' for gravity, and 'perp' or 'axial' for the bar's own axes. The bar is its id as text ('B1'), or the object create_bar_element returned when it is made in the same reply; a list loads several bars (['B1', 'B2']).

Line load: add a load over part of a span¶

A line load covers a whole bar. For "10 kN/m over the second half" put a node where the load stops, so that the loaded part is a bar of its own, and load that bar only:

sec = model.create_rc_section('S1', b=0.3, h=0.5)
n1 = model.create_node(0.0, 0.0)
n2 = model.create_node(1.5, 0.0)       # where the load starts
n3 = model.create_node(3.0, 0.0)
model.create_bar_element(sec, n1, n2)
second = model.create_bar_element(sec, n2, n3)
model.fix(n1)
model.create_load_case('Q')
model.create_uniform_load(second, 'Q', 10, 'down')    # the first half stays unloaded

Line load: add a triangular or trapezoidal load¶

create_bar_distributed_load(bar, case, q_i=..., q_j=...) gives the value at each end of the bar, in kN/m. "Zero at the left end and 20 kN/m at the right end" is:

sec = model.create_rc_section('S1', b=0.25, h=0.5)
n1 = model.create_node(0.0, 0.0)
n2 = model.create_node(5.0, 0.0)
bar = model.create_bar_element(sec, n1, n2)       # from n1 (left) to n2 (right)
model.pin(n1)
model.roller(n2, free='x')
model.create_load_case('Q')
model.create_bar_distributed_load(bar, 'Q', q_i=0, q_j=20, direction='down')

q_i is at the bar's first node, q_j at its second: the order of the nodes in create_bar_element decides which end is which.

Line load: add a point load along a bar¶

model.create_bar_point_load('B1', 'G', 15, at=0.5, direction='down')  # at mid-span

A load in the middle of a bar is applied there; no extra node is needed. at is the fraction of the span from the bar's first node, so a load 2 m from the left support of a 7 m beam is at=2/7.

Line load: edit¶

Change the value of a load on a bar: remove it and create it again.

model.delete_load('B1', 'G')                        # the loads on B1 in case G
model.create_uniform_load('B1', 'G', 15, 'down')    # the new value

Line load: remove¶

Delete the loads on a bar:

model.delete_load('B1', 'G')          # the loads on B1 in case G ('' for every case)

Loads on regions (slabs and walls)¶

Area load: add¶

The region is the object create_polygon made (or its id):

model.create_load_case('Q')
model.create_uniform_load('L1', 'Q', 5, 'down')         # 5 kN/m²
model.create_edge_load('L1', 'top', 'Q', 8)             # kN/m along one edge

Edge names are as in Edges of a region in Slabs and walls.

Area load: edit¶

Change the pressure on a region: remove it and create it again.

model.delete_load('L1', 'Q')
model.create_uniform_load('L1', 'Q', 6, 'down')

Area load: remove¶

Delete the loads on a region:

model.delete_load('L1', 'Q')          # the region's loads in case Q

Self weight¶

Self weight: add¶

Part of the case itself:

model.create_load_case('SW', self_weight_factor=1.0)    # full self weight

or on an existing case: model.create_self_weight(1.0, 'SW').

Self weight: edit¶

Change the self-weight factor of a case:

model.create_self_weight(0.5, 'SW')                     # half of it

Self weight: remove¶

Take the self weight out of a case:

model.create_self_weight(0.0, 'SW')                     # none

Temperature¶

Temperature: add¶

A temperature action goes in a load case of its own. uniform is the change in degrees; gradient is the difference through the depth:

sec = model.create_steel_section('S1', 'IPE300', 'S275')
n1 = model.create_node(0.0, 0.0)
n2 = model.create_node(8.0, 0.0)
bar = model.create_bar_element(sec, n1, n2)
model.fix([n1, n2])
model.create_load_case('T', action_type='temperature')
model.create_temperature(bar, uniform=30, load_case='T')    # a rise of 30 degrees

A list of bars takes the same temperature. With both ends fixed the bar cannot expand and takes an axial force instead.

Temperature: edit¶

Change a temperature action: delete it and create it again with the changed value.

model.create_load_case('T', action_type='temperature')
model.delete_temperature('B2', 'T')
model.create_temperature('B2', uniform=20, load_case='T')

Temperature: remove¶

Delete the temperature loads on a bar:

model.delete_temperature('B2', 'T')   # '' for every case

Settlement of a support¶

Settlement: add¶

A settlement is an imposed displacement of a supported node, in a load case of its own. The sign is the axis: uy negative is downwards, ux positive is to the right. "The middle support settles 10 mm" is uy=-0.01 (metres):

sec = model.create_rc_section('S1', b=0.3, h=0.6)
n1 = model.create_node(0.0, 0.0)
n2 = model.create_node(6.0, 0.0)
n3 = model.create_node(12.0, 0.0)
model.create_bar_element(sec, n1, n2)
model.create_bar_element(sec, n2, n3)
model.pin(n1)
model.roller([n2, n3], free='x')
model.create_load_case('SETTLE')                           # a case of its own
model.create_support_settlement(n2, 'SETTLE', uy=-0.01)    # 10 mm down at the middle support

Settlement: edit¶

Change a settlement: set its displacement again.

for s in model.support_settlements:
    if s.node_id == 'N2':
        s.uy = -0.02                                       # now 20 mm

Settlement: remove¶

Delete the settlement of a support:

model.support_settlements = [s for s in model.support_settlements if s.node_id != 'N2']

Several cases and a combination¶

Loads: combine several cases¶

Each case is loaded on its own; they are combined when the analysis is defined:

model.create_load_case('G')
model.create_load_case('Q')
model.create_uniform_load('B1', 'G', 10, 'down')
model.create_uniform_load('B1', 'Q', 5, 'down')
model.create_analysis_case('ULS', 'Linear', {'G': 1.35, 'Q': 1.5})     # 1.35 G + 1.5 Q

The keys are the case ids as text, or the load case objects create_load_case returned ({g: 1.35, q: 1.5}); both work.

create_load_case already makes a linear analysis case of the same name, so a single case needs nothing more. create_analysis_case(id, 'Linear', {case: factor}) combines several. create_load_combination('C1', {'G': 1.35, 'Q': 1.5}) is for the combinations used in the design checks. See Analysis cases and combinations.

Common mistakes¶

Loads: common mistakes¶

A load on a case that does not exist: create it with create_load_case first.
A negative magnitude with 'down': it points up. Use 'up' instead.
A load on a bar that has not been created yet: the bar comes first.
A load on a bar id you did not see: bar ids follow the order of creation, so in a frame whose columns come first B1 is a column (see Ids in Nodes and bars).