Loads

_FELoadsMixin

Bases: ABC

addFrameLoad(loadCase, tagFrame, tp, GCX1=None, GCX2=None, GCY1=None, GCY2=None, GCZ1=None, GCZ2=None, local=False)

Apply a distributed load or moment to a single frame mesh element.

Each direction is defined by two [relative_distance, value] pairs that describe a linearly varying load along the element length. Relative distances are in [0, 1] where 0 is the start node and 1 is the end node. Omitting GCX2 / GCY2 / GCZ2 replicates the corresponding start value at the element end (uniform load).

Parameters:

Name	Type	Description	Default
loadCase	str	Id of an existing load case.	required
tagFrame	myInt64	Mesh tag of the target frame element.	required
tp	Literal['force', 'moment']	Load type — "force" for distributed force or "moment" for distributed moment.	required
GCX1	Optional[List[float]]	[relative_distance, value] at the start of the load in X.	None
GCX2	Optional[List[float]]	[relative_distance, value] at the end of the load in X. If empty, copied from GCX1 at position 1.0.	None
GCY1	Optional[List[float]]	[relative_distance, value] at the start of the load in Y.	None
GCY2	Optional[List[float]]	[relative_distance, value] at the end of the load in Y. If empty, copied from GCY1 at position 1.0.	None
GCZ1	Optional[List[float]]	[relative_distance, value] at the start of the load in Z.	None
GCZ2	Optional[List[float]]	[relative_distance, value] at the end of the load in Z. If empty, copied from GCZ1 at position 1.0.	None
local	bool	If True, directions are in the element local coordinate system (prefix L); otherwise in the global system (prefix G).	False

Raises:

Type	Description
EXAExceptions	If loadCase is not a string or is unknown, if tagFrame is not in the mesh, if tp is invalid, if any load list has the wrong length or contains non-float values.

addLoadCase(idCase, tp='U', descr='')

Register a new load case.

Parameters:

Name	Type	Description	Default
idCase	str	Unique string identifier for the load case.	required
tp	str	Load case type code from configData["LoadCaseType"] (e.g. "D" for Dead Load, "L" for Live Load, "W" for Wind, "E" for Earthquake). Default is "U" (User Defined).	'U'
descr	str	Optional human-readable description.	''

Raises:

Type	Description
EXAExceptions	If idCase or tp are not strings, if tp is not a known type code, or if idCase already exists.

addLoadCombination(keyCombination, combination)

Register a load combination.

The combination coefficients must appear in the same order as the load cases were added (Python dicts preserve insertion order from 3.7+).

Parameters:

Name	Type	Description	Default
keyCombination	str	Unique string identifier for the combination.	required
combination	List[float]	List of scale factors, one per load case in insertion order.	required

addMacroFrameLoadLine(loadCase, tagsMacro, tp, direction, load_value_1, load_value_2, load_position_absolute=True, local=False)

Apply a linearly-varying distributed load over a macro-frame alignment.

The load is distributed across all mesh frames that belong to tagsMacro, spanning from load_value_1 to load_value_2 along the alignment's local axis 3. Each underlying frame element receives the correct trapezoidal portion of the load, including partial coverage (the load window may start or end inside a frame element).

Parameters:

Name	Type	Description	Default
loadCase	str	Identifier of the load case to add the load to.	required
tagsMacro	List[myInt64]	List of macro-element tags that define the alignment. All elements must be collinear and ordered along the same axis.	required
tp	Literal['force', 'moment']	Load type — "force" for a distributed force or "moment" for a distributed moment.	required
direction	Literal['X', 'Y', 'Z']	Global Cartesian direction of the load — "X", "Y", or "Z".	required
load_value_1	List[float]	[position, intensity] at the left boundary of the load window. position is an absolute distance from the start of the alignment when load_position_absolute is True, or a relative coordinate in [0, 1) otherwise. intensity is the load magnitude at that point.	required
load_value_2	List[float]	[position, intensity] at the right boundary of the load window. position must be greater than load_value_1[0] and at most the alignment length (or 1.0 in relative mode).	required
load_position_absolute	bool	If True (default), positions in load_value_1 and load_value_2 are absolute distances [length units]; they are normalised internally to [0, 1]. If False, positions are already relative.	True
local	bool	If True, the load direction is interpreted in the local frame reference; if False (default) it is global.	False

Raises:

Type	Description
EXAExceptions	If load_value_1 does not have exactly 2 elements, if the normalised position of load_value_1 is outside [0, 1), or if load_value_2 position is not in (load_value_1[0], 1].

addMultiFrameLoad(loadCase, tagsFrames, tp, GCX1=None, GCX2=None, GCY1=None, GCY2=None, GCZ1=None, GCZ2=None, local=False)

Apply a distributed load or moment to multiple frame mesh elements.

Delegates to :meth:addFrameLoad for each tag in tagsFrames. See :meth:addFrameLoad for a full description of the load parameters.

Parameters:

Name	Type	Description	Default
loadCase	str	Id of an existing load case.	required
tagsFrames	List[myInt64]	List of mesh frame element tags to load.	required
tp	Literal['force', 'moment']	Load type — "force" for distributed force or "moment" for distributed moment.	required
GCX1	Optional[List[float]]	[relative_distance, value] at the start of the load in X.	None
GCX2	Optional[List[float]]	[relative_distance, value] at the end of the load in X.	None
GCY1	Optional[List[float]]	[relative_distance, value] at the start of the load in Y.	None
GCY2	Optional[List[float]]	[relative_distance, value] at the end of the load in Y.	None
GCZ1	Optional[List[float]]	[relative_distance, value] at the start of the load in Z.	None
GCZ2	Optional[List[float]]	[relative_distance, value] at the end of the load in Z.	None
local	bool	If True, interpret directions in the element local coordinate system; otherwise in the global system.	False

Raises:

Type	Description
EXAExceptions	If tagsFrames is not a list, or if any per-element call to :meth:addFrameLoad fails.

addMultiFrameLoadHydro(loadCase, tagsMacro, dirLoad, gamma, K, H0, p0, Bref, local=False, coordVariation='Z', oneSignPositive=None, constValue=False)

Add a linear load on macro-element

Parameters:

Name	Type	Description	Default
constValue		if true value is considered constant on frame p0 * Bref	False
loadCase		load case as str	required
tagsMacro		macro-element tag	required
dirLoad		load direction	required
gamma		peso del terreno specifico	required
K		coefficiente di spinta del terreno	required
H0		distanza dallo zero della copertura del terreno	required
p0		pressione di partenza ovvero il sovraccarico	required
Bref		largezza di riferimento per il calcolo della pressione	required
local		reference system for pressure direction	False
coordVariation		coordinate in global reference that for variation	'Z'
oneSignPositive		If None function considers positive and negative values, If True function considers only positive values and negative values if it is False	None

addMultiFrameWinklerSpring(tagsMacro, tp, dirSprings, subgradeModulus, Bref)

Convert a Winkler subgrade modulus into nodal springs for multiple frame macro-elements.

For each mesh frame element belonging to the specified macro-elements, the tributary length is computed and the equivalent nodal spring stiffness is distributed equally to the two end nodes.

Unlike :meth:assignFrameWinklerSupport, which stores the support parameters directly on the frame, this method immediately creates nodal springs by calling :meth:addNodeSpring on each node.

Parameters:

Name	Type	Description	Default
tagsMacro	List[myInt64]	List of macro-element tags whose mesh frames are processed.	required
tp	NodalSpringsTp	Spring behaviour type (LINEAR, COMP, or TENS).	required
dirSprings	NodalSpringsDir	Global direction of the spring (e.g. DZ+).	required
subgradeModulus	float	Winkler subgrade modulus [force/length³].	required
Bref	int	Reference width used to convert the modulus to a linear stiffness per unit length [length].	required

Raises:

Type	Description
EXAExceptions	If tagsMacro is not a list.

addMultiNodeContraints(tagsNodes, dof)

Apply boundary condition constraints to multiple mesh nodes.

Delegates to :meth:addNodeContraints for each tag in tagsNodes.

Parameters:

Name	Type	Description	Default
tagsNodes	List[myInt64]	List of mesh node tags to constrain.	required
dof	List[bool]	Degrees-of-freedom flags [Tx, Ty, Tz, Rx, Ry, Rz]. True means the DOF is restrained.	required

Raises:

Type	Description
EXAExceptions	If tagsNodes is not a list.

addMultiNodeLoad(loadCase, tagsNodes, NCS)

Apply a nodal load to multiple mesh nodes.

Delegates to :meth:assignNodeLoad for each tag in tagsNodes.

Parameters:

Name	Type	Description	Default
loadCase	str	Id of an existing load case.	required
tagsNodes	List[myInt64]	List of mesh node tags to load.	required
NCS	List[float]	Nodal Coordinate System force/moment vector [Fx, Fy, Fz, Mx, My, Mz] — all values must be floats.	required

Raises:

Type	Description
EXAExceptions	If tagsNodes is not a list.

addMultiNodeSpring(tagsNodes, tp, dirSpring, stiffness)

Add a nodal spring to multiple mesh nodes.

Delegates to :meth:addNodeSpring for each tag in tagsNodes.

Parameters:

Name	Type	Description	Default
tagsNodes	List[myInt64]	List of mesh node tags to spring.	required
tp	NodalSpringsTp	Spring behaviour type (LINEAR, COMP, or TENS).	required
dirSpring	NodalSpringsDir	Direction of the spring (e.g. DZ+).	required
stiffness	float	Spring stiffness in force/length units.	required

Raises:

Type	Description
EXAExceptions	If tagsNodes is not a list.

addNodeContraints(tagNode, dof)

Apply boundary condition constraints to a single mesh node.

Parameters:

Name	Type	Description	Default
tagNode	myInt64	Mesh tag of the target node.	required
dof	List[bool]	Degrees-of-freedom flags [Tx, Ty, Tz, Rx, Ry, Rz]. True means the DOF is restrained. Must be a list of exactly 6 booleans.	required

Raises:

Type	Description
EXAExceptions	If tagNode is not in the mesh, if dof contains non-bool values, or if its length is not 6.

addNodeSpring(tagNode, tp, dirSpring, stiffness, add=False)

Add or accumulate a nodal spring on a single mesh node.

Parameters:

Name	Type	Description	Default
tagNode	myInt64 | int	Mesh tag of the target node (int or numpy.uint64).	required
tp	NodalSpringsTp	Spring behaviour type (LINEAR, COMP, or TENS).	required
dirSpring	NodalSpringsDir	Direction of the spring (e.g. DZ+).	required
stiffness	float	Spring stiffness in force/length units.	required
add	bool	If True and a spring of the same tp and dirSpring already exists on the node, the stiffness is accumulated (added). If False the existing value is overwritten. Default is False.	False

Raises:

Type	Description
EXAExceptions	If tagNode is not an int or numpy.uint64, if tp is not a :class:NodalSpringsTp, if dirSpring is not a :class:NodalSpringsDir, or if stiffness is not a float.

addSelfWeight(loadCase, GCS)

Add a self-weight (gravity) load to a load case.

Parameters:

Name	Type	Description	Default
loadCase	str	Id of an existing load case.	required
GCS	List[float]	Global Coordinate System multipliers [Gx, Gy, Gz]. Each value scales the gravitational acceleration in that global direction (e.g. [0.0, 0.0, -1.0] applies 1 g downward). All values must be floats and the list must have length 3.	required

Raises:

Type	Description
EXAExceptions	If loadCase is not a string, if loadCase is unknown, if GCS contains non-float values, or if its length is not 3.

assignFrameTemperature(loadCase, tagFrame, temp, tpTemp='gradient')

Assign a temperature gradient to a single frame element for a given load case.

Parameters:

Name	Type	Description	Default
loadCase	str	Id of an existing load case.	required
tagFrame	int	Mesh tag of the target frame element.	required
temp	Tuple[float, float]	Temperature pair (temp_top, temp_bottom) in degrees Celsius, representing the gradient across the section depth.	required
tpTemp	Literal['gradient']	Type of temperature assignment. Currently only "gradient" is supported.	'gradient'

Raises:

Type	Description
EXAExceptions	If loadCase is not a string, if loadCase is unknown, if tagFrame is not in the mesh, if tpTemp is not a valid type, or if temp is not a 2-tuple.

assignNodeLoad(loadCase, tagNode, NCS)

Apply a nodal load to a single mesh node.

Parameters:

Name	Type	Description	Default
loadCase	str	Id of an existing load case.	required
tagNode	myInt64	Mesh tag of the target node.	required
NCS	List[float]	Nodal Coordinate System force/moment vector [Fx, Fy, Fz, Mx, My, Mz]. All 6 values must be floats.	required

Raises:

Type	Description
EXAExceptions	If loadCase is not a string or is unknown, if tagNode is not in the mesh, if NCS contains non-float values, or if its length is not 6.

assignNodeTemperature(loadCase, tagNode, temp, tpTemp='fixed')

Assign a temperature value to a single mesh node for a given load case.

Parameters:

Name	Type	Description	Default
loadCase	str	Id of an existing load case.	required
tagNode	int	Mesh tag of the target node.	required
temp	float	Temperature value in degrees Celsius.	required
tpTemp	Literal['fixed', 'reference', 'initial']	Type of temperature assignment. One of: "fixed" — node temperature is imposed (default). "reference" — used as reference for thermal strain. "initial" — initial condition temperature.	'fixed'

Raises:

Type	Description
EXAExceptions	If loadCase is not a string, if loadCase is unknown, if tagNode is not in the mesh, if temp is not a float, or if tpTemp is not a string.

getFrameTemperatures()

Return the frame temperature (gradient) assignments.

Returns:

Type	Description
Dict[str, Dict[int, Dict[str, Tuple[float, float]]]]	Nested dict structured as
Dict[str, Dict[int, Dict[str, Tuple[float, float]]]]	{load_case: {frame_tag: {temperature_type: (value_i, value_j)}}}.
Dict[str, Dict[int, Dict[str, Tuple[float, float]]]]	Currently only the "gradient" temperature type is supported.

getInertialAcceleration()

Return the inertial acceleration (body-force) assigned to each load case.

Returns:

Type	Description
Dict[str, Tuple[float, float, float]]	A dict mapping each load case id to its acceleration vector
Dict[str, Tuple[float, float, float]]	(ax, ay, az) in model units.

getInitialTemperatures()

Return the uniform initial temperature assigned to each load case.

Returns:

Type	Description
Dict[str, float]	A dict mapping each load case id to its initial (reference)
Dict[str, float]	temperature value.

getLoadCases()

Return all registered load cases.

Returns:

Type	Description
Dict[str, Tuple[str, str]]	A dict mapping each load case id to a tuple (type_code, description).

getLoadCombinations()

Return all registered load combinations.

Returns:

Type	Description
Dict[str, List[float]]	A dict mapping each combination id to its list of scale factors.

getLoads()

Return all load data organised by load case.

Returns:

Type	Description
Dict[str, Dict[LoadType, Any]]	Nested dict structured as
Dict[str, Dict[LoadType, Any]]	{load_case_id: {LoadType: load_data}}.

getNodeContraints()

Return all nodal boundary condition constraints.

Returns:

Type	Description
Dict[myInt64, Tuple[bool, bool, bool, bool, bool, bool]]	A dict mapping each constrained node tag to a 6-tuple of booleans
Dict[myInt64, Tuple[bool, bool, bool, bool, bool, bool]]	(Tx, Ty, Tz, Rx, Ry, Rz) where True means the DOF is restrained.

getNodeSprings()

Return all nodal spring assignments.

Returns:

Type	Description
Dict[myInt64, Dict[NodalSpringsTp, Dict[NodalSpringsDir, float]]]	Nested dict structured as
Dict[myInt64, Dict[NodalSpringsTp, Dict[NodalSpringsDir, float]]]	{node_tag: {spring_type: {direction: stiffness}}}.

getNodeTemperatures()

Return the node temperature assignments.

Returns:

Type	Description
Dict[str, Dict[int, Dict[str, float]]]	Nested dict structured as
Dict[str, Dict[int, Dict[str, float]]]	{load_case: {node_tag: {temperature_type: value}}}.
Dict[str, Dict[int, Dict[str, float]]]	Temperature types are "fixed", "reference", or "initial".

setInertialAcceleration(loadCase, acc)

Set the inertial (body-force) acceleration for a load case.

Parameters:

Name	Type	Description	Default
loadCase	str	Id of an existing load case.	required
acc	Tuple[float, float, float]	Acceleration vector (ax, ay, az) in model units. Must be a 3-tuple of floats.	required

Raises:

Type	Description
EXAExceptions	If loadCase is not a string, if loadCase is unknown, if acc is not a tuple, or if its length is not 3.

setInitialTemperature(loadCase, temp)

Set the uniform initial (reference) temperature for a load case.

Parameters:

Name	Type	Description	Default
loadCase	str	Id of an existing load case.	required
temp	float	Initial temperature value in degrees Celsius.	required

Raises:

Type	Description
EXAExceptions	If loadCase is not a string, if loadCase is unknown, or if temp is not a float.