simdesign.rcmrf.bnsm.baselib.beam

This module provides a base class for representing beams within the BNSM layer and for building and exporting their OpenSees representations.

class simdesign.rcmrf.bnsm.baselib.beam.BeamBase(design, bondslip_factor, load_factors, cyclic_model=False, cracked_section=None, load_type='point', yield_mom_curv='empirical')[source]

Bases: ABC

Abstract Base Class for beam implementations in BNSM layer.

This class defines the common interface and core behaviour required to: (1) define a beam member in the OpenSees domain, and (2) export equivalent Python and Tcl commands.

The member is modelled using a force-based beam-column element (forceBeamColumn) with a plastic-hinge integration scheme (e.g., HingeRadau). Nonlinear behaviour is concentrated within finite hinge lengths at the element ends.

Hinge behaviour is defined through phenomenological moment-rotation relationships implemented using uniaxial materials and section aggregators. The interior region is represented by an elastic section, with optional use of cracked-section (effective) stiffness properties.

A bond-slip modification factor is applied when determining hinge properties (i.e., rotation capacities). Uniformly distributed gravity loads are assigned to the beam element.

Many section-level quantities are stored as Array3 values, corresponding to the (i, mid, j) sections.

Parameters:

design (BeamBase)
bondslip_factor (float)
load_factors (Dict[Literal['G', 'Q'], float])
cyclic_model (bool)
cracked_section (None | bool | float)
load_type (Literal['uniform', 'point'])
yield_mom_curv (Literal['empirical', 'analytical'])

design

Instance of beam design information model.

Type:: BeamBase

bondslip_factor

Bondslip factor.

Type:: float

ele_node_i

Element node at the start of beam.

Type:: Node

ele_node_j

Element node at the end of beam.

Type:: Node

ele_load

Uniformly distributed gravity load along the beam.

Type:: float

load_type

How the gravity load is applied: ‘uniform’ as a uniformly distributed element load, ‘point’ as equivalent point loads at the element ends (as in O’Reilly and Sullivan, 2019).

Type:: Literal[‘uniform’, ‘point’]

jnt_offsets

Rigid joint offset values (dx_i, dy_i, dz_i, dx_j, dy_j, dz_j), specified with respect to the global coordinate system.

Type:: List[float]

cracked

Cracked-section (effective) flexural properties of the elastic sections: True for EIeff = My / phi_y with the yield moment and curvature of the plastic hinges computed with the empirical or analytical approach (see yield_mom_curv), or a float as the ratio of effective to gross flexural stiffness. If None or False, gross-section properties are used. The class attribute is the method used for the BNSM option 'auto' (see the model classes).

Type:: None | bool | float

yield_mom_curv

Method to compute yield moment and curvature of the plastic hinges: 'empirical' (Panagiotakos and Fardis, 2001) or 'analytical' (simplified section analysis).

Type:: Literal[‘empirical’, ‘analytical’]

cyclic_model

If True, the model parameters will be adjusted for cyclic analysis.

Type:: bool

_Iz_eff

Effective beam moment of inertia around local-z.

Type:: float

Notes

Section view of beams along X direction:

Z (3)
|__Y (2)
    --------------    ----
    |     y      |    |
    |     |      |    |
    |  z--+      |    h
    |            |    |
    |            |    |
    --------------    ----
    |---- b -----|

Vectors defining the local axes in Global Coordinate System:
    vx = np.array([1.0, 0.0, 0.0])
    vy = np.array([0.0, 0.0, 1.0])
    vz = np.array([0.0, -1.0, 0.0])
    vecxz = np.array([0.0, -1.0, 0.0])
Compatibility check:
    np.allclose(vy, np.cross(vecxz, vx))
    np.allclose(vz, np.cross(vx,vy))

Section view of beams along Y direction:

Z (3)
|__X (1)
    --------------    ----
    |     y      |    |
    |     |      |    |
    |     +--z   |    h
    |            |    |
    |            |    |
    --------------    ----
    |---- b -----|

Vectors defining the local axes in Global Coordinate System:
    vx = np.array([0.0, 1.0, 0.0])
    vy = np.array([0.0, 0.0, 1.0])
    vz = np.array([1.0, 0.0, 0.0])
    vecxz = np.array([1.0, 0.0, 0.0])
Compatibility check:
    np.allclose(vy, np.cross(vecxz, vx))
    np.allclose(vz, np.cross(vx,vy))

property ele_tag: int

Returns:: Tag of beam-column element representing the beam.
Return type:: int

property Ecm_q: float

Returns:: Elastic young’s modulus of concrete (in base units).
Return type:: float

Note

Based on quality adjusted concrete strength.

property Gcm_q: float

Returns:: Elastic shear modulus of concrete (in base units).
Return type:: float

Note

Based on quality adjusted concrete strength.

property rhoh_z_q: Annotated[ndarray[tuple[Any, ...], dtype[float64]], Literal[3]]

Returns:: In situ (quality adjusted) transverse reinforcement ratio in local-z.
Return type:: Array3[np.float64]

property rhoh_y_q: Annotated[ndarray[tuple[Any, ...], dtype[float64]], Literal[3]]

Returns:: In situ (quality adjusted) transverse reinforcement ratio in local-y.
Return type:: Array3[np.float64]

property rhol_top_q: Annotated[ndarray[tuple[Any, ...], dtype[float64]], Literal[3]]

Returns:: In situ (quality adjusted) top longitudinal reinforcement ratio.
Return type:: Array3[np.float64]

property rhol_bot_q: Annotated[ndarray[tuple[Any, ...], dtype[float64]], Literal[3]]

Returns:: In situ (quality adjusted) bottom longitudinal reinforcement ratio.
Return type:: Array3[np.float64]

property rhol_q: Annotated[ndarray[tuple[Any, ...], dtype[float64]], Literal[3]]

Returns:: In situ (quality adjusted) total longitudinal reinforcement ratio.
Return type:: Array3[np.float64]

property rhoh_z_q_: Annotated[ndarray[tuple[Any, ...], dtype[float64]], Literal[3]]

Returns:: In situ (quality adjusted) transverse reinforcement ratio in local-z. Computed using confined concrete dimensions.
Return type:: Array3[np.float64]

property rhoh_y_q_: Annotated[ndarray[tuple[Any, ...], dtype[float64]], Literal[3]]

Returns:: In situ (quality adjusted) transverse reinforcement ratio in local-y. Computed using confined concrete dimensions.
Return type:: Array3[np.float64]

property rhol_top_q_: Annotated[ndarray[tuple[Any, ...], dtype[float64]], Literal[3]]

Returns:: In situ (quality adjusted) top longitudinal reinforcement ratio. Computed using confined concrete dimensions.
Return type:: Array3[np.float64]

property rhol_bot_q_: Annotated[ndarray[tuple[Any, ...], dtype[float64]], Literal[3]]

Returns:: In situ (quality adjusted) bottom longitudinal reinforcement ratio. Computed using confined concrete dimensions.
Return type:: Array3[np.float64]

property rhol_q_: Annotated[ndarray[tuple[Any, ...], dtype[float64]], Literal[3]]

Returns:: In situ (quality adjusted) total longitudinal reinforcement ratio. Computed using confined concrete dimensions.
Return type:: Array3[np.float64]

property vecxz: List[float]

Local x-z plane vector in global coordinates for OpenSees geometric transformation.

Returns:: (X, Y, Z) components of vecxz used by ops.geomTransf to define the local element axes.
Return type:: List[float]

Notes

For beams along global X (1): [0, -1, 0]
For beams along global Y (2): [1, 0, 0]

property mz_i_mat_tag: int: Material tag for the i-end flexural hinge about local-z (Mz).

property mz_j_mat_tag: int: Material tag for the j-end flexural hinge about local-z (Mz).

property elastic_sec_tag: int: Section tag for the elastic (interior) section.

property inelastic_sec_i_tag: int: Section tag for the inelastic (hinge) section at i-end.

property inelastic_sec_j_tag: int: Section tag for the inelastic (hinge) section at j-end.

property int_tag: int: Beam integration tag used by OpenSees.

property geo_transf_tag: int: Geometric transformation tag used by OpenSees.

property clear_length: float: Length of the deformable element, without the rigid joint offsets.

add_to_ops()[source]

Adds beam components to the OpenSees domain (i.e, elastic beam element and nodes).

Return type:: None

to_py()[source]

Gets the Python commands to construct beam components in OpenSees domain (i.e, beam element and nodes).

Returns:: List of Python commands for constructing the components of beam object in OpenSees.
Return type:: List[str]

to_tcl()[source]

Gets the Tcl commands to construct beam components in OpenSees domain (i.e, beam element and nodes).

Returns:: List of Tcl commands for constructing the components of beam object in OpenSees.
Return type:: List[str]

property end_gaps: Tuple[float, float]

Lengths of the beam line at the i and j ends that are not part of the deformable element (rigid joint offsets or links).

Returns:: Gap lengths at the i and j ends.
Return type:: Tuple[float, float]

add_grav_loads_to_ops()[source]

Adds gravity load objects to the OpenSees domain (i.e, uniformly distributed loads, or point loads at both ends).

Notes

Both options apply the total load over the beam line length.

Return type:: None

to_py_grav_loads()[source]

Gets the Python commands to construct beam gravity load objects in OpenSees domain (i.e, uniformly distributed loads, or point loads at both ends).

Returns:: List of Python commands for adding beam gravity loads to OpenSees.
Return type:: List[str]

to_tcl_grav_loads()[source]

Gets the Tcl commands to construct beam gravity load objects in OpenSees domain (i.e, uniformly distributed loads, or point loads at both ends).

Returns:: List of Tcl commands for adding beam gravity loads to OpenSees.
Return type:: List[str]