o3seespy.element

Base element

class o3seespy.command.element.base_element.ElementBase

Bases: OpenSeesObject

op_base_type = 'element'

Beam-column

class o3seespy.command.element.beam_column.DispBeamColumn(osi, ele_nodes, transf, integration, c_mass=False, mass: Optional[float] = None)

Bases: ElementBase

The DispBeamColumn Element Class

Create a dispBeamColumn element.

Initial method for DispBeamColumn

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – List of two node objects

• transf (obj) – Object of transformation

• integration (obj) – Object of beamintegration()

• c_mass (None) –

• mass (float, optional) – Element mass density (per unit length), from which a lumped-mass matrix is formed

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> i_node = o3.node.Node(osi, 0.0, 0.0)
>>> j_node = o3.node.Node(osi, 0.0, 1.0)
>>> transf = o3.geom_transf.Linear2D(osi, [])
>>> sec = o3.section.Elastic2D(osi, 10.0, 1.0, 1.0)
>>> integration = o3.beam_integration.Lobatto(osi, sec, 5)
>>> o3.element.DispBeamColumn(osi, ele_nodes=[i_node, j_node], transf=transf, integration=integration, c_mass=1, mass=0.0)

op_type = 'dispBeamColumn'

class o3seespy.command.element.beam_column.DispBeamColumnInt(osi, ele_nodes, num_intgr_pts, sec, transf, c_rot, mass: Optional[float] = None)

Bases: ElementBase

The DispBeamColumnInt Element Class

This command is used to construct a dispBeamColumnInt element object, which is a distributed-plasticity, displacement-based beam-column element which includes interaction between flexural and shear components.

Initial method for DispBeamColumnInt

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• num_intgr_pts (int) – Number of integration points along the element.

• sec (obj) – Identifier for previously-defined section object

• transf (obj) – Identifier for previously-defined coordinate-transformation (crdtransf) object

• c_rot (float) – Identifier for element center of rotation (or center of curvature distribution). fraction of the height distance from bottom to the center of rotation (0 to 1)

• mass (float, optional) – Element mass density (per unit length), from which a lumped-mass matrix is formed (optional, default=0.0)

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> sec = o3.section.Elastic2D(osi, 10.0, 1.0, 1.0)
>>> transf = o3.geom_transf.Linear2D(osi, [])
>>> o3.element.DispBeamColumnInt(osi, ele_nodes=ele_nodes, num_intgr_pts=4, sec=sec, transf=transf, c_rot=1.0, mass=1.0)

op_type = 'dispBeamColumnInt'

class o3seespy.command.element.beam_column.ElasticBeamColumn2D(osi, ele_nodes, area, e_mod, iz, transf, mass: Optional[float] = None, c_mass=False, release_code=None)

Bases: ElementBase

The ElasticBeamColumn2D Element Class

This command is used to construct an elasticBeamColumn element object. The arguments for the construction of an elastic beam-column element depend on the dimension of the problem, (ndm)

For a two-dimensional problem

Initial method for ElasticBeamColumn2D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• area (float) – Cross-sectional area of element

• e_mod (float) – Young’s modulus

• iz (float) – Second moment of area about the local z-axis

• transf (obj) – Identifier for previously-defined coordinate-transformation (crdtransf) object

• mass (float, optional) – Element mass per unit length (optional, default = 0.0)

• c_mass (bool) – To form consistent mass matrix (optional, default = lumped mass matrix)

• release_code (None, optional) –

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> transf = o3.geom_transf.Linear2D(osi, [])
>>> o3.element.ElasticBeamColumn2D(osi, ele_nodes=ele_nodes, area=1.0, e_mod=1.0, iz=1.0, transf=transf, mass=1.0)

op_type = 'elasticBeamColumn'

class o3seespy.command.element.beam_column.ElasticBeamColumn3D(osi, ele_nodes, area, e_mod, g_mod, jxx, iy, iz, transf, mass: Optional[float] = None, c_mass=False)

Bases: ElementBase

The ElasticBeamColumn3D Element Class

This command is used to construct an elasticBeamColumn element object. The arguments for the construction of an elastic beam-column element depend on the dimension of the problem, (ndm)

For a three-dimensional problem

Initial method for ElasticBeamColumn3D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• area (float) – Cross-sectional area of element

• e_mod (float) – Young’s modulus

• g_mod (float) – Shear modulus

• jxx (float) – Torsional moment of inertia of cross section

• iy (float) – Second moment of area about the local y-axis

• iz (float) – Second moment of area about the local z-axis

• transf (obj) – Identifier for previously-defined coordinate-transformation (crdtransf) object

• mass (float, optional) – Element mass per unit length (optional, default = 0.0)

• c_mass (bool) – To form consistent mass matrix (optional, default = lumped mass matrix)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=3)
>>> coords = [[0, 0, 0], [1, 0, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> #transf = o3.geom_transf.Linear3D(osi, [])
>>> transf = o3.geom_transf.Linear3D(osi, vecxz=[1.0, 1.0, 0.0], d_i=[1.0, 1.0, 0.0], d_j=[1.0, 1.0, 0.5])
>>> o3.element.ElasticBeamColumn3D(osi, ele_nodes=ele_nodes, area=1.0, e_mod=1.0, g_mod=1.0, jxx=1.0, iy=1.0, iz=1.0, transf=transf, mass=1.0)

op_type = 'elasticBeamColumn'

class o3seespy.command.element.beam_column.ElasticTimoshenkoBeam2D(osi, ele_nodes, e_mod, g_mod, area, iz, avy, transf, c_mass=False, mass: Optional[float] = None)

Bases: ElementBase

The ElasticTimoshenkoBeam2D Element Class

This command is used to construct an ElasticTimoshenkoBeam element object. A Timoshenko beam is a frame member that accounts for shear deformations. The arguments for the construction of an elastic Timoshenko beam element depend on the dimension of the problem, ndm:

For a two-dimensional problem:

Initial method for ElasticTimoshenkoBeam2D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• e_mod (float) – Young’s modulus

• g_mod (float) – Shear modulus

• area (float) – Cross-sectional area of element

• iz (float) – Second moment of area about the local z-axis

• avy (float) – Shear area for the local y-axis

• transf (obj) – Identifier for previously-defined coordinate-transformation (crdtransf) object

• c_mass (bool) – To form consistent mass matrix (optional, default = lumped mass matrix)

• mass (float, optional) – Element mass per unit length (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> transf = o3.geom_transf.Linear2D(osi, [])
>>> o3.element.ElasticTimoshenkoBeam2D(osi, ele_nodes=ele_nodes, e_mod=1.0, g_mod=1.0, area=1.0, iz=1.0, avy=1.0, transf=transf, mass=1.0)

op_type = 'ElasticTimoshenkoBeam'

class o3seespy.command.element.beam_column.ElasticTimoshenkoBeam3D(osi, ele_nodes, e_mod, g_mod, area, iz, jxx, iy, iz_2, avy, avz, transf, c_mass=False, mass: Optional[float] = None)

Bases: ElementBase

The ElasticTimoshenkoBeam3D Element Class

This command is used to construct an ElasticTimoshenkoBeam element object. A Timoshenko beam is a frame member that accounts for shear deformations. The arguments for the construction of an elastic Timoshenko beam element depend on the dimension of the problem, ndm:

For a three-dimensional problem:

Initial method for ElasticTimoshenkoBeam3D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• e_mod (float) – Young’s modulus

• g_mod (float) – Shear modulus

• area (float) – Cross-sectional area of element

• iz (float) – Second moment of area about the local z-axis

• jxx (float) – Torsional moment of inertia of cross section

• iy (float) – Second moment of area about the local y-axis

• iz_2 (None) –

• avy (float) – Shear area for the local y-axis

• avz (float) – Shear area for the local z-axis

• transf (obj) – Identifier for previously-defined coordinate-transformation (crdtransf) object

• c_mass (bool) – To form consistent mass matrix (optional, default = lumped mass matrix)

• mass (float, optional) – Element mass per unit length (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=3)
>>> coords = [[0, 0, 0], [1, 0, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> transf = o3.geom_transf.Linear3D(osi, vecxz=[1.0, 1.0, 0.0], d_i=[1.0, 1.0, 0.0], d_j=[1.0, 1.0, 0.5])
>>> o3.element.ElasticTimoshenkoBeam3D(osi, ele_nodes=ele_nodes, e_mod=1.0, g_mod=1.0, area=1.0, iz=1.0, jxx=1.0, iy=1.0, iz_2=1, avy=1.0, avz=1.0, transf=transf, mass=1.0, c_mass=True)

op_type = 'ElasticTimoshenkoBeam'

class o3seespy.command.element.beam_column.ForceBeamColumn(osi, ele_nodes, transf, integration, max_iter: Optional[int] = None, tol: Optional[float] = None, mass: Optional[float] = None)

Bases: ElementBase

The ForceBeamColumn Element Class

Create a ForceBeamColumn element.

Initial method for ForceBeamColumn

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• transf (obj) – Object of transformation

• integration (obj) – Object of beamintegration()

• max_iter (int, optional) – Maximum number of iterations to undertake to satisfy element compatibility

• tol (float, optional) – Tolerance for satisfaction of element compatibility

• mass (float, optional) – Element mass density (per unit length), from which a lumped-mass matrix is formed

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> i_node = o3.node.Node(osi, 0.0, 0.0)
>>> j_node = o3.node.Node(osi, 0.0, 1.0)
>>> transf = o3.geom_transf.Linear2D(osi, [])
>>> sec = o3.section.Elastic2D(osi, 10.0, 1.0, 1.0)
>>> integration = o3.beam_integration.Lobatto(osi, sec, 5)
>>> o3.element.ForceBeamColumn(osi, ele_nodes=[i_node, j_node], transf=transf, integration=integration, max_iter=10, tol=1e-12, mass=0.0)

op_type = 'forceBeamColumn'

class o3seespy.command.element.beam_column.MVLEM(osi, dens, ele_nodes, m, c, thick: Optional[list] = None, widths: Optional[list] = None, rho: Optional[list] = None, mat_concretes: Optional[list] = None, mat_steels: Optional[list] = None, mat_shear=None)

Bases: ElementBase

The MVLEM Element Class

Developed and implemented by: | Kristijan Kolozvari (CSU Fullerton)| Kutay

Orakcal (Bogazici University)| John Wallace (UCLA)The MVLEM element command is used to generate a two-dimensional Multiple-Vertical-Line-Element-Model (MVLEM; Vulcano et al., 1988; Orakcal et al., 2004, Kolozvari et al., 2015) for simulation of flexure-dominated RC wall behavior. A single model element incorporates six global degrees of freedom, three of each located at the center of rigid top and bottom beams, as illustrated in Figure 1a. The axial/flexural response of the MVLEM is simulated by a series of uniaxial elements (or macro-fibers) connected to the rigid beams at the top and bottom (e.g., floor) levels, whereas the shear response is described by a shear spring located at height ch from the bottom of the wall element (Figure 1a). Shear and flexural responses of the model element are uncoupled. The relative rotation between top and bottom faces of the wall element occurs about the point located on the central axis of the element at height ch (Figure 1b). Rotations and resulting transverse displacements are calculated based on the wall curvature, derived from section and material properties, corresponding to the bending moment at height ch of each element (Figure 1b). A value of c=0.4 was recommended by Vulcano et al. (1988) based on comparison of the model response with experimental results.

Initial method for MVLEM

Parameters

• osi (o3seespy.OpenSeesInstance) –

• dens (float) – Wall density

• ele_nodes (list) – A list of two element nodes

• m (int) – Number of element macro-fibers

• c (float) – Location of center of rotation from the inode, c = 0.4 (recommended)

• thick (list, optional) – A list of m macro-fiber thicknesses

• widths (list, optional) – A list of m macro-fiber widths

• rho (list, optional) – A list of m reinforcing ratios corresponding to macro-fibers; for each fiber:

• mat_concretes (list, optional) – A list of m uniaxial_material objects for concrete

• mat_steels (list, optional) – A list of m uniaxial_material objects for steel

• mat_shear (obj, optional) – Object of uniaxial_material for shear material

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> mat_conc = [o3.uniaxial_material.Concrete01(osi, fpc=1.0, epsc0=1.0, fpcu=1.0, eps_u=1.0),
>>>             o3.uniaxial_material.Concrete01(osi, fpc=1.0, epsc0=1.0, fpcu=1.0, eps_u=1.0)]
>>> mat_steel = [o3.uniaxial_material.Steel02(osi, fy=1.0, e0=1.0, b=1.0, params=[15, 0.925, 0.15])]
>>> mat_shear = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> o3.element.MVLEM(osi, dens=1.0, ele_nodes=ele_nodes, m=1, c=1.0, thick=[1.0], widths=[1, 1], rho=[1., 1.],
>>>                  mat_concretes=mat_conc, mat_steels=mat_steel, mat_shear=mat_shear)

op_type = 'MVLEM'

class o3seespy.command.element.beam_column.ModElasticBeam2D(osi, ele_nodes, area, e_mod, iz, k11, k33, k44, transf, c_mass=False, mass: Optional[float] = None)

Bases: ElementBase

The ModElasticBeam2D Element Class

This command is used to construct a ModElasticBeam2d element object. The arguments for the construction of an elastic beam-column element with stiffness modifiers is applicable for 2-D problems. This element should be used for modelling of a structural element with an equivalent combination of one elastic element with stiffness-proportional damping, and two springs at its two ends with no stiffness proportional damping to represent a prismatic section. The modelling technique is based on a number of analytical studies discussed in Zareian and Medina (2010) and Zareian and Krawinkler (2009) and is utilized in order to solve problems related to numerical damping in dynamic analysis of frame structures with concentrated plasticity springs.

Initial method for ModElasticBeam2D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• area (float) – Cross-sectional area of element

• e_mod (float) – Young’s modulus

• iz (float) – Second moment of area about the local z-axis

• k11 (float) – Stiffness modifier for translation

• k33 (float) – Stiffness modifier for translation

• k44 (float) – Stiffness modifier for rotation

• transf (obj) – Identifier for previously-defined coordinate-transformation (crdtransf) object

• c_mass (bool) – To form consistent mass matrix (optional, default = lumped mass matrix)

• mass (float, optional) – Element mass per unit length (optional, default = 0.0)

op_type = 'ModElasticBeam2d'

class o3seespy.command.element.beam_column.NonlinearBeamColumn(osi, ele_nodes, num_intgr_pts, sec, transf, max_iter: Optional[int] = None, tol: Optional[float] = None, mass: Optional[float] = None, int_type: Optional[str] = None)

Bases: ElementBase

The NonlinearBeamColumn Element Class

Create a nonlinearBeamColumn element. This element is for backward compatability.

Initial method for NonlinearBeamColumn

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• num_intgr_pts (int) – Number of integration points.

• sec (obj) – Object of section

• transf (obj) – Object of transformation

• max_iter (int, optional) – Maximum number of iterations to undertake to satisfy element compatibility

• tol (float, optional) – Tolerance for satisfaction of element compatibility

• mass (float, optional) – Element mass density (per unit length), from which a lumped-mass matrix is formed

• int_type (str, optional) – Integration type (optional, default is 'Lobatto') * 'Lobatto' * 'Trapezoidal' * 'radau' * 'newtoncotes' * 'trapezoidal'

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> i_node = o3.node.Node(osi, 0.0, 0.0)
>>> j_node = o3.node.Node(osi, 0.0, 1.0)
>>> sec = o3.section.Elastic2D(osi, 10.0, 1.0, 1.0)
>>> transf = o3.geom_transf.Linear2D(osi, [])
>>> o3.element.NonlinearBeamColumn(osi, ele_nodes=[i_node, j_node], num_intgr_pts=1, sec=sec, transf=transf,
>>>                                max_iter=10, tol=1e-12, mass=0.0, int_type="radau")

op_type = 'nonlinearBeamColumn'

class o3seespy.command.element.beam_column.SFIMVLEM(osi, ele_nodes, m, c, thick=None, widths=None, mats: Optional[list] = None)

Bases: ElementBase

The SFIMVLEM Element Class

Developed and implemented by: | Kristijan Kolozvari (CSU Fullerton)| Kutay

Orakcal (Bogazici University)| Leonardo Massone (University of Chile, Santiago)| John Wallace (UCLA)The SFI_MVLEM command is used to construct a Shear-Flexure Interaction Multiple-Vertical-Line-Element Model (SFI-MVLEM, Kolozvari et al., 2018, 2015a, b, c; Kolozvari 2013), which captures interaction between axial/flexural and shear behavior of RC structural walls and columns under cyclic loading. The SFI_MVLEM element (Figure 1) incorporates 2-D RC panel behavior described by the Fixed-Strut-Angle-Model (nDMaterial FSAM; Ulugtekin, 2010; Orakcal et al., 2012), into a 2-D macroscopic fiber-based model (MVLEM). The interaction between axial and shear behavior is captured at each RC panel (macro-fiber) level, which further incorporates interaction between shear and flexural behavior at the SFI_MVLEM element level.

Initial method for SFIMVLEM

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• m (int) – Number of element macro-fibers

• c (float) – Location of center of rotation with from the inode, c = 0.4 (recommended)

• thick (None, optional) –

• widths (None, optional) –

• mats (list, optional) – A list of m macro-fiber ndmaterial1 objects

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> mats = [o3.nd_material.ElasticIsotropic(osi, 1.0, 0.3), o3.nd_material.ElasticIsotropic(osi, 1.0, 0.3)]
>>> o3.element.SFIMVLEM(osi, ele_nodes=ele_nodes, m=1, c=1.0, thick=[1.0], widths=[1.0, 1.0], mats=mats)

op_type = 'SFI_MVLEM'

Bearing

class o3seespy.command.element.bearing.ElastomericBearingBoucWen2D(osi, ele_nodes, k_init, qd, alpha1, alpha2, mu, eta, beta, gamma, p_mat=None, mz_mat=None, orient_vals: Optional[list] = None, shear_dist: Optional[float] = None, do_rayleigh=False, mass: Optional[float] = None)

Bases: ElementBase

The ElastomericBearingBoucWen2D Element Class

This command is used to construct an elastomericBearing element object, which is defined by two nodes. The element can have zero length or the appropriate bearing height. The bearing has unidirectional (2D) or coupled (3D) plasticity properties for the shear deformations, and force-deformation behaviors defined by UniaxialMaterials in the remaining two (2D) or four (3D) directions. By default (sDratio = 0.5) P-Delta moments are equally distributed to the two end-nodes. To avoid the introduction of artificial viscous damping in the isolation system (sometimes referred to as “damping leakage in the isolation system”), the bearing element does not contribute to the Rayleigh damping by default. If the element has non-zero length, the local x-axis is determined from the nodal geometry unless the optional x-axis vector is specified in which case the nodal geometry is ignored and the user-defined orientation is utilized.

For a two-dimensional problem

Initial method for ElastomericBearingBoucWen2D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• k_init (float) – Initial elastic stiffness in local shear direction

• qd (float) – Characteristic strength

• alpha1 (float) – Post yield stiffness ratio of linear hardening component

• alpha2 (float) – Post yield stiffness ratio of non-linear hardening component

• mu (float) – Exponent of non-linear hardening component

• eta (float) – Yielding exponent (sharpness of hysteresis loop corners) (default = 1.0)

• beta (float) – First hysteretic shape parameter (default = 0.5)

• gamma (float) – Second hysteretic shape parameter (default = 0.5)

• p_mat (obj, optional) – Object associated with previously-defined uniaxial_material in axial direction

• mz_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local z-axis

• orient_vals (list, optional) – Vector components in global coordinates defining local x-axis , vector components in global coordinates defining local y-axis

• shear_dist (float, optional) – Shear distance from inode as a fraction of the element length (optional, default = 0.5)

• do_rayleigh (bool) – To include rayleigh damping from the bearing (optional, default = no rayleigh damping contribution)

• mass (float, optional) – Element mass (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> orient_vals = [1, 0, 0, 1, 0, 1]
>>> p_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> mz_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> o3.element.ElastomericBearingBoucWen2D(osi, ele_nodes=ele_nodes, k_init=1.0, qd=1.0, alpha1=1.0, alpha2=1.0,
>>>                                        mu=1.0, eta=1.0, beta=1.0, gamma=1.0, p_mat=p_mat, mz_mat=mz_mat,
>>>                                        orient_vals=orient_vals, shear_dist=1.0, do_rayleigh=False, mass=1.0)

op_type = 'elastomericBearingBoucWen'

class o3seespy.command.element.bearing.ElastomericBearingBoucWen3D(osi, ele_nodes, k_init, qd, alpha1, alpha2, mu, eta, beta, gamma, p_mat=None, t_mat=None, my_mat=None, mz_mat=None, orient_vals: Optional[list] = None, shear_dist: Optional[float] = None, do_rayleigh=False, mass: Optional[float] = None)

Bases: ElementBase

The ElastomericBearingBoucWen3D Element Class

This command is used to construct an elastomericBearing element object, which is defined by two nodes. The element can have zero length or the appropriate bearing height. The bearing has unidirectional (2D) or coupled (3D) plasticity properties for the shear deformations, and force-deformation behaviors defined by UniaxialMaterials in the remaining two (2D) or four (3D) directions. By default (sDratio = 0.5) P-Delta moments are equally distributed to the two end-nodes. To avoid the introduction of artificial viscous damping in the isolation system (sometimes referred to as “damping leakage in the isolation system”), the bearing element does not contribute to the Rayleigh damping by default. If the element has non-zero length, the local x-axis is determined from the nodal geometry unless the optional x-axis vector is specified in which case the nodal geometry is ignored and the user-defined orientation is utilized.

For a three-dimensional problem

Initial method for ElastomericBearingBoucWen3D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• k_init (float) – Initial elastic stiffness in local shear direction

• qd (float) – Characteristic strength

• alpha1 (float) – Post yield stiffness ratio of linear hardening component

• alpha2 (float) – Post yield stiffness ratio of non-linear hardening component

• mu (float) – Exponent of non-linear hardening component

• eta (float) – Yielding exponent (sharpness of hysteresis loop corners) (default = 1.0)

• beta (float) – First hysteretic shape parameter (default = 0.5)

• gamma (float) – Second hysteretic shape parameter (default = 0.5)

• p_mat (obj, optional) – Object associated with previously-defined uniaxial_material in axial direction

• t_mat (obj, optional) – Object associated with previously-defined uniaxial_material in torsional direction

• my_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local y-axis

• mz_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local z-axis

• orient_vals (list, optional) – Vector components in global coordinates defining local x-axis , vector components in global coordinates defining local y-axis

• shear_dist (float, optional) – Shear distance from inode as a fraction of the element length (optional, default = 0.5)

• do_rayleigh (bool) – To include rayleigh damping from the bearing (optional, default = no rayleigh damping contribution)

• mass (float, optional) – Element mass (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=3, ndf=6)
>>> coords = [[0, 0, 0], [0, 1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> orient_vals = [1, 0, 0]
>>> p_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> mz_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> t_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> my_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> o3.element.ElastomericBearingBoucWen3D(osi, ele_nodes=ele_nodes, k_init=1.0, qd=1.0, alpha1=1.0, alpha2=1.0,
>>>                                        mu=1.0, eta=1.0, beta=1.0, gamma=1.0, p_mat=p_mat, t_mat=t_mat,
>>>                                        my_mat=my_mat, mz_mat=mz_mat, orient_vals=orient_vals,
>>>                                        shear_dist=1.0, do_rayleigh=False, mass=1.0)

op_type = 'elastomericBearingBoucWen'

class o3seespy.command.element.bearing.ElastomericBearingPlasticity2D(osi, ele_nodes, k_init, qd, alpha1, alpha2, mu, p_mat=None, mz_mat=None, do_rayleigh=False, orient=None, mass: Optional[float] = None, shear_dist: Optional[float] = None)

Bases: ElementBase

The ElastomericBearingPlasticity2D Element Class

This command is used to construct an elastomericBearing element object, which is defined by two nodes. The element can have zero length or the appropriate bearing height. The bearing has unidirectional (2D) or coupled (3D) plasticity properties for the shear deformations, and force-deformation behaviors defined by UniaxialMaterials in the remaining two (2D) or four (3D) directions. By default (sDratio = 0.5) P-Delta moments are equally distributed to the two end-nodes. To avoid the introduction of artificial viscous damping in the isolation system (sometimes referred to as “damping leakage in the isolation system”), the bearing element does not contribute to the Rayleigh damping by default. If the element has non-zero length, the local x-axis is determined from the nodal geometry unless the optional x-axis vector is specified in which case the nodal geometry is ignored and the user-defined orientation is utilized.

For a two-dimensional problem

Initial method for ElastomericBearingPlasticity2D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• k_init (float) – Initial elastic stiffness in local shear direction

• qd (float) – Characteristic strength

• alpha1 (float) – Post yield stiffness ratio of linear hardening component

• alpha2 (float) – Post yield stiffness ratio of non-linear hardening component

• mu (float) – Exponent of non-linear hardening component

• p_mat (obj, optional) – Object associated with previously-defined uniaxial_material in axial direction

• mz_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local z-axis

• do_rayleigh (bool) – To include rayleigh damping from the bearing (optional, default = no rayleigh damping contribution)

• orient (None, optional) –

• mass (float, optional) – Element mass (optional, default = 0.0)

• shear_dist (float, optional) – Shear distance from inode as a fraction of the element length (optional, default = 0.5)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> p_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> mz_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> o3.element.ElastomericBearingPlasticity2D(osi, ele_nodes=ele_nodes, k_init=1.0, qd=1.0, alpha1=1.0, alpha2=1.0,
>>>                                           mu=1.0, p_mat=p_mat, mz_mat=mz_mat)

op_type = 'elastomericBearingPlasticity'

class o3seespy.command.element.bearing.ElastomericBearingPlasticity3D(osi, ele_nodes, k_init, qd, alpha1, alpha2, mu, p_mat=None, t_mat=None, my_mat=None, mz_mat=None, do_rayleigh=False, orient=None, mass: Optional[float] = None, shear_dist: Optional[float] = None)

Bases: ElementBase

The ElastomericBearingPlasticity3D Element Class

This command is used to construct an elastomericBearing element object, which is defined by two nodes. The element can have zero length or the appropriate bearing height. The bearing has unidirectional (2D) or coupled (3D) plasticity properties for the shear deformations, and force-deformation behaviors defined by UniaxialMaterials in the remaining two (2D) or four (3D) directions. By default (sDratio = 0.5) P-Delta moments are equally distributed to the two end-nodes. To avoid the introduction of artificial viscous damping in the isolation system (sometimes referred to as “damping leakage in the isolation system”), the bearing element does not contribute to the Rayleigh damping by default. If the element has non-zero length, the local x-axis is determined from the nodal geometry unless the optional x-axis vector is specified in which case the nodal geometry is ignored and the user-defined orientation is utilized.

For a three-dimensional problem

Initial method for ElastomericBearingPlasticity3D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• k_init (float) – Initial elastic stiffness in local shear direction

• qd (float) – Characteristic strength

• alpha1 (float) – Post yield stiffness ratio of linear hardening component

• alpha2 (float) – Post yield stiffness ratio of non-linear hardening component

• mu (float) – Exponent of non-linear hardening component

• p_mat (obj, optional) – Object associated with previously-defined uniaxial_material in axial direction

• t_mat (obj, optional) – Object associated with previously-defined uniaxial_material in torsional direction

• my_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local y-axis

• mz_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local z-axis

• do_rayleigh (bool) – To include rayleigh damping from the bearing (optional, default = no rayleigh damping contribution)

• orient (None, optional) –

• mass (float, optional) – Element mass (optional, default = 0.0)

• shear_dist (float, optional) – Shear distance from inode as a fraction of the element length (optional, default = 0.5)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=3, ndf=6)
>>> coords = [[0, 0, 0], [0, 1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> p_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> mz_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> t_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> my_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> orient_vals = [1, 0, 0]
>>> o3.element.ElastomericBearingPlasticity3D(osi, ele_nodes=ele_nodes, k_init=1.0, qd=1.0, alpha1=1.0, alpha2=1.0,
>>>                                           mu=1.0, p_mat=p_mat, t_mat=t_mat, my_mat=my_mat, mz_mat=mz_mat,
>>>                                           orient=orient_vals)

op_type = 'elastomericBearingPlasticity'

class o3seespy.command.element.bearing.ElastomericX(osi, ele_nodes, fy, alpha, gr, kbulk, d1, d2, ts, tr, n, x1, x2, x3, y1, y2, y3, kc, phi_m, ac, s_dratio, m, cd, tc, tag1, tag2, tag3, tag4)

Bases: ElementBase

The ElastomericX Element Class

This command is used to construct an ElastomericX bearing element object in three-dimension. The 3D continuum geometry of an elastomeric bearing is modeled as a 2-node, 12 DOF discrete element. This elements extends the formulation of Elastomeric_Bearing_(Bouc-Wen)_Element element. However, instead of the user providing material models as input arguments, it only requires geometric and material properties of an elastomeric bearing as arguments. The material models in six direction are formulated within the element from input arguments. The time-dependent values of mechanical properties (e.g., shear stiffness, buckling load capacity) can also be recorded using the “parameters” recorder.

For 3D problem

Initial method for ElastomericX

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• fy (float) – Yield strength

• alpha (float) – Post-yield stiffness ratio

• gr (float) – Shear modulus of elastomeric bearing

• kbulk (float) – Bulk modulus of rubber

• d1 (float) – Internal diameter

• d2 (float) – Outer diameter (excluding cover thickness)

• ts (float) – Single steel shim layer thickness

• tr (float) – Single rubber layer thickness

• n (int) – Number of rubber layers

• x1 (float) – Vector components in global coordinates defining local x-axis

• x2 (float) – Vector components in global coordinates defining local x-axis

• x3 (float) – Vector components in global coordinates defining local x-axis

• y1 (float) – Vector components in global coordinates defining local y-axis

• y2 (float) – Vector components in global coordinates defining local y-axis

• y3 (float) – Vector components in global coordinates defining local y-axis

• kc (float) – Cavitation parameter (optional, default = 10.0)

• phi_m (float) – Damage parameter (optional, default = 0.5)

• ac (float) – Strength reduction parameter (optional, default = 1.0)

• s_dratio (float) – Shear distance from inode as a fraction of the element length (optional, default = 0.5)

• m (float) – Element mass (optional, default = 0.0)

• cd (float) – Viscous damping parameter (optional, default = 0.0)

• tc (float) – Cover thickness (optional, default = 0.0)

• tag1 (float) – Object to include cavitation and post-cavitation (optional, default = 0)

• tag2 (float) – Object to include buckling load variation (optional, default = 0)

• tag3 (float) – Object to include horizontal stiffness variation (optional, default = 0)

• tag4 (float) – Object to include vertical stiffness variation (optional, default = 0)

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> o3.element.ElastomericX(osi, ele_nodes=ele_nodes, fy=1.0, alpha=1.0, gr=1.0, kbulk=1.0, d1=1.0, d2=1.0, ts=1.0,
>>>                         tr=1.0, n=1, x1=1.0, x2=1.0, x3=1.0, y1=1.0, y2=1.0, y3=1.0, kc=1.0, phi_m=1.0, ac=1.0,
>>>                         s_dratio=1.0, m=1.0, cd=1.0, tc=1.0, tag1=0, tag2=0, tag3=0, tag4=0)

op_type = 'ElastomericX'

class o3seespy.command.element.bearing.FPBearingPTV(osi, ele_nodes, mu_ref, is_pressure_dependent, p_ref, is_temperature_dependent, diffusivity, conductivity, is_velocity_dependent, rate_parameter, reffective_fp, radius_contact, k_initial, the_material_a, the_material_b, the_material_c, the_material_d, x1, x2, x3, y1, y2, y3, shear_dist, do_rayleigh, mass, max_iter, tol, unit)

Bases: ElementBase

The FPBearingPTV Element Class

The FPBearingPTV command creates a single Friction Pendulum bearing element, which is capable of accounting for the changes in the coefficient of friction at the sliding surface with instantaneous values of the sliding velocity, axial pressure and temperature at the sliding surface. The constitutive modelling is similar to the existing singleFPBearing element, otherwise. The FPBearingPTV element has been verified and validated in accordance with the ASME guidelines, details of which are presented in Chapter 4 of Kumar et al. (2015a).

Initial method for FPBearingPTV

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• mu_ref (float) – Reference coefficient of friction

• is_pressure_dependent (int) – 1 if the coefficient of friction is a function of instantaneous axial pressure

• p_ref (float) – Reference axial pressure (the bearing pressure under static loads)

• is_temperature_dependent (int) – 1 if the coefficient of friction is a function of instantaneous temperature at the sliding surface

• diffusivity (float) – Thermal diffusivity of steel

• conductivity (float) – Thermal conductivity of steel

• is_velocity_dependent (int) – 1 if the coefficient of friction is a function of instantaneous velocity at the sliding surface

• rate_parameter (float) – The exponent that determines the shape of the coefficient of friction vs. sliding velocity curve

• reffective_fp (float) – Effective radius of curvature of the sliding surface of the fpbearing

• radius_contact (float) – Radius of contact area at the sliding surface

• k_initial (float) – Lateral stiffness of the sliding bearing before sliding begins

• the_material_a (int) – Object for the uniaxial material in the axial direction

• the_material_b (int) – Object for the uniaxial material in the torsional direction

• the_material_c (int) – Object for the uniaxial material for rocking about local y axis

• the_material_d (int) – Object for the uniaxial material for rocking about local z axis

• x1 (float) – Vector components to define local x axis

• x2 (float) – Vector components to define local x axis

• x3 (float) – Vector components to define local x axis

• y1 (float) – Vector components to define local y axis

• y2 (float) – Vector components to define local y axis

• y3 (float) – Vector components to define local y axis

• shear_dist (float) – Shear distance from inode as a fraction of the length of the element

• do_rayleigh (int) – To include rayleigh damping from the bearing

• mass (float) – Element mass

• max_iter (int) – Maximum number of iterations to satisfy the equilibrium of element

• tol (float) – Convergence tolerance to satisfy the equilibrium of the element

• unit (int) – Object to identify the unit from the list below. * 1: n, m, s, c * 2: kn, m, s, c * 3: n, mm, s, c * 4: kn, mm, s, c * 5: lb, in, s, c * 6: kip, in, s, c * 7: lb, ft, s, c * 8: kip, ft, s, c

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> o3.element.FPBearingPTV(osi, ele_nodes=ele_nodes, mu_ref=1.0, is_pressure_dependent=1, p_ref=1.0, is_temperature_dependent=1, diffusivity=1.0, conductivity=1.0, is_velocity_dependent=1, rate_parameter=1.0, reffective_fp=1.0, radius__contact=1.0, k_initial=1.0, the_material_a=1, the_material_b=1, the_material_c=1, the_material_d=1, x1=1.0, x2=1.0, x3=1.0, y1=1.0, y2=1.0, y3=1.0, shear_dist=1.0, do_rayleigh=1, mass=1.0, max_iter=1, tol=1.0, unit=1)

op_type = 'FPBearingPTV'

class o3seespy.command.element.bearing.FlatSliderBearing2D(osi, ele_nodes, frn_mdl, k_init, p_mat=None, mz_mat=None, do_rayleigh=False, max_iter: Optional[int] = None, tol: Optional[float] = None, orient=None, mass: Optional[float] = None, shear_dist: Optional[float] = None)

Bases: ElementBase

The FlatSliderBearing2D Element Class

This command is used to construct a flatSliderBearing element object, which is defined by two nodes. The iNode represents the flat sliding surface and the jNode represents the slider. The element can have zero length or the appropriate bearing height. The bearing has unidirectional (2D) or coupled (3D) friction properties for the shear deformations, and force-deformation behaviors defined by UniaxialMaterials in the remaining two (2D) or four (3D) directions. To capture the uplift behavior of the bearing, the user-specified UniaxialMaterial in the axial direction is modified for no-tension behavior. By default (sDratio = 0.0) P-Delta moments are entirely transferred to the flat sliding surface (iNode). It is important to note that rotations of the flat sliding surface (rotations at the iNode) affect the shear behavior of the bearing. To avoid the introduction of artificial viscous damping in the isolation system (sometimes referred to as “damping leakage in the isolation system”), the bearing element does not contribute to the Rayleigh damping by default. If the element has non-zero length, the local x-axis is determined from the nodal geometry unless the optional x-axis vector is specified in which case the nodal geometry is ignored and the user-defined orientation is utilized.

For a two-dimensional problem

Initial method for FlatSliderBearing2D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• frn_mdl (obj) – Object associated with previously-defined frictionmodel

• k_init (float) – Initial elastic stiffness in local shear direction

• p_mat (obj, optional) – Object associated with previously-defined uniaxial_material in axial direction

• mz_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local z-axis

• do_rayleigh (bool) – To include rayleigh damping from the bearing (optional, default = no rayleigh damping contribution)

• max_iter (int, optional) – Maximum number of iterations to undertake to satisfy element equilibrium (optional, default = 20)

• tol (float, optional) – Convergence tolerance to satisfy element equilibrium (optional, default = 1e-8)

• orient (list, optional) – [x1, x2, x3, y1, y2, y3] defines local x and y, note that local x is in the P direction, whereas friction acts along y. Therefore [0, 1, 0, -1, 0, 0] is a normal setup for a horizontal slider.

• mass (float, optional) – Element mass (optional, default = 0.0)

• shear_dist (float, optional) – Shear distance from inode as a fraction of the element length (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> p_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> mz_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> frn1 = o3.friction_model.Coulomb(osi, mu=1.0)
>>> o3.element.FlatSliderBearing2D(osi, ele_nodes=ele_nodes, frn_mdl=frn1, k_init=1.0, p_mat=p_mat, mz_mat=mz_mat,
>>>                                do_rayleigh=False, max_iter=1, tol=1.0, orient=None, mass=1.0, shear_dist=1.0)

op_type = 'flatSliderBearing'

class o3seespy.command.element.bearing.FlatSliderBearing3D(osi, ele_nodes, frn_mdl, k_init, p_mat=None, t_mat=None, my_mat=None, mz_mat=None, do_rayleigh=False, max_iter=None, tol: Optional[float] = None, orient=None, mass: Optional[float] = None, shear_dist: Optional[float] = None)

Bases: ElementBase

The FlatSliderBearing3D Element Class

This command is used to construct a flatSliderBearing element object, which is defined by two nodes. The iNode represents the flat sliding surface and the jNode represents the slider. The element can have zero length or the appropriate bearing height. The bearing has unidirectional (2D) or coupled (3D) friction properties for the shear deformations, and force-deformation behaviors defined by UniaxialMaterials in the remaining two (2D) or four (3D) directions. To capture the uplift behavior of the bearing, the user-specified UniaxialMaterial in the axial direction is modified for no-tension behavior. By default (sDratio = 0.0) P-Delta moments are entirely transferred to the flat sliding surface (iNode). It is important to note that rotations of the flat sliding surface (rotations at the iNode) affect the shear behavior of the bearing. To avoid the introduction of artificial viscous damping in the isolation system (sometimes referred to as “damping leakage in the isolation system”), the bearing element does not contribute to the Rayleigh damping by default. If the element has non-zero length, the local x-axis is determined from the nodal geometry unless the optional x-axis vector is specified in which case the nodal geometry is ignored and the user-defined orientation is utilized.

For a three-dimensional problem

Initial method for FlatSliderBearing3D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• frn_mdl (obj) – Object associated with previously-defined frictionmodel

• k_init (float) – Initial elastic stiffness in local shear direction

• p_mat (obj, optional) – Object associated with previously-defined uniaxial_material in axial direction

• t_mat (obj, optional) – Object associated with previously-defined uniaxial_material in torsional direction

• my_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local y-axis

• mz_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local z-axis

• do_rayleigh (bool) – To include rayleigh damping from the bearing (optional, default = no rayleigh damping contribution)

• max_iter (None, optional) –

• tol (float, optional) – Convergence tolerance to satisfy element equilibrium (optional, default = 1e-8)

• orient (None, optional) –

• mass (float, optional) – Element mass (optional, default = 0.0)

• shear_dist (float, optional) – Shear distance from inode as a fraction of the element length (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=3, ndf=6)
>>> coords = [[0, 0, 0], [0, 1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> p_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> mz_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> t_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> my_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> frn1 = o3.friction_model.Coulomb(osi, mu=1.0)
>>> orient_vals = [1, 0, 0]
>>> o3.element.FlatSliderBearing3D(osi, ele_nodes=ele_nodes, frn_mdl=frn1, k_init=1.0, p_mat=p_mat, t_mat=t_mat,
>>>                                my_mat=my_mat, mz_mat=mz_mat, do_rayleigh=False, max_iter=None, tol=None,
>>>                                mass=1.0, shear_dist=1.0, orient=orient_vals)

op_type = 'flatSliderBearing'

class o3seespy.command.element.bearing.HDR(osi, ele_nodes, gr, kbulk, d1, d2, ts, tr, n, a1, a2, a3, b1, b2, b3, c1, c2, c3, c4, x1, x2, x3, y1, y2, y3, kc, phi_m, ac, s_dratio, m, tc)

Bases: ElementBase

The HDR Element Class

For 3D problem

Initial method for HDR

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• gr (float) – Shear modulus of elastomeric bearing

• kbulk (float) – Bulk modulus of rubber

• d1 (float) – Internal diameter

• d2 (float) – Outer diameter (excluding cover thickness)

• ts (float) – Single steel shim layer thickness

• tr (float) – Single rubber layer thickness

• n (int) – Number of rubber layers

• a1 (float) – Parameters of the grant model

• a2 (float) – Parameters of the grant model

• a3 (float) – Parameters of the grant model

• b1 (float) – Parameters of the grant model

• b2 (float) – Parameters of the grant model

• b3 (float) – Parameters of the grant model

• c1 (float) – Parameters of the grant model

• c2 (float) – Parameters of the grant model

• c3 (float) – Parameters of the grant model

• c4 (float) – Parameters of the grant model

• x1 (float) – Vector components in global coordinates defining local x-axis

• x2 (float) – Vector components in global coordinates defining local x-axis

• x3 (float) – Vector components in global coordinates defining local x-axis

• y1 (float) – Vector components in global coordinates defining local y-axis

• y2 (float) – Vector components in global coordinates defining local y-axis

• y3 (float) – Vector components in global coordinates defining local y-axis

• kc (float) – Cavitation parameter (optional, default = 10.0)

• phi_m (float) – Damage parameter (optional, default = 0.5)

• ac (float) – Strength reduction parameter (optional, default = 1.0)

• s_dratio (float) – Shear distance from inode as a fraction of the element length (optional, default = 0.5)

• m (float) – Element mass (optional, default = 0.0)

• tc (float) – Cover thickness (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> o3.element.HDR(osi, ele_nodes=ele_nodes, gr=1.0, kbulk=1.0, d1=1.0, d2=1.0, ts=1.0, tr=1.0, n=1, a1=1.0, a2=1.0, a3=1.0, b1=1.0, b2=1.0, b3=1.0, c1=1.0, c2=1.0, c3=1.0, c4=1.0, x1=1.0, x2=1.0, x3=1.0, y1=1.0, y2=1.0, y3=1.0, kc=1.0, phi_m=1.0, ac=1.0, s_dratio=1.0, m=1.0, tc=1.0)

op_type = 'HDR'

class o3seespy.command.element.bearing.KikuchiBearingadjustPDOutput(osi, ele_nodes, total_rubber, ci, cj, shape: Optional[float] = None, size: Optional[float] = None, total_height: Optional[float] = None, n_mss: Optional[int] = None, mat_mss=None, lim_disp: Optional[float] = None, n_mns: Optional[int] = None, mat_mns=None, lamb: Optional[float] = None, no_pd_input=False, no_tilt=False, orient=None, mass: Optional[float] = None)

Bases: ElementBase

The KikuchiBearingadjustPDOutput Element Class

This command is used to construct a KikuchiBearing element object, which is defined by two nodes. This element consists of multiple shear spring model (MSS) and multiple normal spring model (MNS).

Initial method for KikuchiBearingadjustPDOutput

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• total_rubber (float) – Total rubber thickness

• ci (float) – P-delta moment adjustment for reaction force (default: ci =0.5, cj =0.5)

• cj (float) – P-delta moment adjustment for reaction force (default: ci =0.5, cj =0.5)

• shape (float, optional) – Following shapes are available: round, square

• size (float, optional) – Diameter (round shape), length of edge (square shape)

• total_height (float, optional) – Total height of the bearing (defaulut: distance between inode and jnode)

• n_mss (int, optional) – Number of springs in mss = nmss

• mat_mss (obj, optional) – Matobject for mss

• lim_disp (float, optional) – Minimum deformation to calculate equivalent coefficient of mss (see note 1)

• n_mns (int, optional) – Number of springs in mns = nmns*nmns (for round and square shape)

• mat_mns (obj, optional) – Matobject for mns

• lamb (float, optional) – Parameter to calculate compression modulus distribution on mns (see note 2)

• no_pd_input (bool) – Not consider p-delta moment

• no_tilt (bool) – Not consider tilt of rigid link

• orient (None, optional) –

• mass (float, optional) – Element mass

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat_mss = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> mat_mns = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> o3.element.KikuchiBearingadjustPDOutput(osi, ele_nodes=ele_nodes, shape=1.0, size=1.0, total_rubber=1.0, total_height=1.0, n_mss=1, mat_mss=mat_mss, lim_disp=1.0, n_mns=1, mat_mns=mat_mns, lamb=1.0, no_pd_input="string", no_tilt="string", ci=1.0, cj=1.0, orient=[0.0, 0.0], mass=1.0)

op_type = 'KikuchiBearing'

class o3seespy.command.element.bearing.KikuchiBearingdoBalance(osi, ele_nodes, total_rubber, lim_fo, lim_fi, n_iter, shape: Optional[float] = None, size: Optional[float] = None, total_height: Optional[float] = None, n_mss: Optional[int] = None, mat_mss=None, lim_disp: Optional[float] = None, n_mns: Optional[int] = None, mat_mns=None, lamb: Optional[float] = None, no_pd_input=False, no_tilt=False, orient=None, mass: Optional[float] = None)

Bases: ElementBase

The KikuchiBearingdoBalance Element Class

This command is used to construct a KikuchiBearing element object, which is defined by two nodes. This element consists of multiple shear spring model (MSS) and multiple normal spring model (MNS).

Initial method for KikuchiBearingdoBalance

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• total_rubber (float) – Total rubber thickness

• lim_fo (float) – Tolerance of external unbalanced force ( limfo), tolorance of internal unbalanced force ( limfi), number of iterations to get rid of internal unbalanced force ( niter)

• lim_fi (float) – Tolerance of external unbalanced force ( limfo), tolorance of internal unbalanced force ( limfi), number of iterations to get rid of internal unbalanced force ( niter)

• n_iter (float) – Tolerance of external unbalanced force ( limfo), tolorance of internal unbalanced force ( limfi), number of iterations to get rid of internal unbalanced force ( niter)

• shape (float, optional) – Following shapes are available: round, square

• size (float, optional) – Diameter (round shape), length of edge (square shape)

• total_height (float, optional) – Total height of the bearing (defaulut: distance between inode and jnode)

• n_mss (int, optional) – Number of springs in mss = nmss

• mat_mss (obj, optional) – Matobject for mss

• lim_disp (float, optional) – Minimum deformation to calculate equivalent coefficient of mss (see note 1)

• n_mns (int, optional) – Number of springs in mns = nmns*nmns (for round and square shape)

• mat_mns (obj, optional) – Matobject for mns

• lamb (float, optional) – Parameter to calculate compression modulus distribution on mns (see note 2)

• no_pd_input (bool) – Not consider p-delta moment

• no_tilt (bool) – Not consider tilt of rigid link

• orient (None, optional) –

• mass (float, optional) – Element mass

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat_mss = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> mat_mns = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> o3.element.KikuchiBearingdoBalance(osi, ele_nodes=ele_nodes, shape=1.0, size=1.0, total_rubber=1.0, total_height=1.0, n_mss=1, mat_mss=mat_mss, lim_disp=1.0, n_mns=1, mat_mns=mat_mns, lamb=1.0, no_pd_input="string", no_tilt="string", lim_fo=1.0, lim_fi=1.0, n_iter=1.0, orient=[0.0, 0.0], mass=1.0)

op_type = 'KikuchiBearing'

class o3seespy.command.element.bearing.LeadRubberX(osi, ele_nodes, fy, alpha, gr, kbulk, d1, d2, ts, tr, n, x1, x2, x3, y1, y2, y3, kc, phi_m, ac, s_dratio, m, cd, tc, q_l, c_l, k_s, a_s, tag1, tag2, tag3, tag4, tag5)

Bases: ElementBase

The LeadRubberX Element Class

This command is used to construct a LeadRubberX bearing element object in three-dimension. The 3D continuum geometry of a lead rubber bearing is modeled as a 2-node, 12 DOF discrete element. It extends the formulation of ElastomericX by including strength degradation in lead rubber bearing due to heating of the lead-core. The LeadRubberX element requires only the geometric and material properties of an elastomeric bearing as arguments. The material models in six direction are formulated within the element from input arguments. The time-dependent values of mechanical properties (e.g., shear stiffness, buckling load capacity, temperature in the lead-core, yield strength) can also be recorded using the “parameters” recorder.

Initial method for LeadRubberX

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• fy (float) – Yield strength

• alpha (float) – Post-yield stiffness ratio

• gr (float) – Shear modulus of elastomeric bearing

• kbulk (float) – Bulk modulus of rubber

• d1 (float) – Internal diameter

• d2 (float) – Outer diameter (excluding cover thickness)

• ts (float) – Single steel shim layer thickness

• tr (float) – Single rubber layer thickness

• n (int) – Number of rubber layers

• x1 (float) – Vector components in global coordinates defining local x-axis

• x2 (float) – Vector components in global coordinates defining local x-axis

• x3 (float) – Vector components in global coordinates defining local x-axis

• y1 (float) – Vector components in global coordinates defining local y-axis

• y2 (float) – Vector components in global coordinates defining local y-axis

• y3 (float) – Vector components in global coordinates defining local y-axis

• kc (float) – Cavitation parameter (optional, default = 10.0)

• phi_m (float) – Damage parameter (optional, default = 0.5)

• ac (float) – Strength reduction parameter (optional, default = 1.0)

• s_dratio (float) – Shear distance from inode as a fraction of the element length (optional, default = 0.5)

• m (float) – Element mass (optional, default = 0.0)

• cd (float) – Viscous damping parameter (optional, default = 0.0)

• tc (float) – Cover thickness (optional, default = 0.0)

• q_l (float) – Density of lead (optional, default = 11200 kg/m3)

• c_l (float) – Specific heat of lead (optional, default = 130 n-m/kg oc)

• k_s (float) – Thermal conductivity of steel (optional, default = 50 w/m oc)

• a_s (float) – Thermal diffusivity of steel (optional, default = 1.41e-05 m2/s)

• tag1 (int) – Object to include cavitation and post-cavitation (optional, default = 0)

• tag2 (int) – Object to include buckling load variation (optional, default = 0)

• tag3 (int) – Object to include horizontal stiffness variation (optional, default = 0)

• tag4 (int) – Object to include vertical stiffness variation (optional, default = 0)

• tag5 (int) – Object to include strength degradation in shear due to heating of lead core (optional, default = 0)

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> o3.element.LeadRubberX(osi, ele_nodes=ele_nodes, fy=1.0, alpha=1.0, gr=1.0, kbulk=1.0, d1=1.0, d2=1.0, ts=1.0,
>>>                        tr=1.0, n=1, x1=1.0, x2=1.0, x3=1.0, y1=1.0, y2=1.0, y3=1.0, kc=1.0, phi_m=1.0, ac=1.0,
>>>                        s_dratio=1.0, m=1.0, cd=1.0, tc=1.0, q_l=1.0, c_l=1.0, k_s=1.0, a_s=1.0,
>>>                        tag1=1, tag2=1, tag3=1, tag4=1, tag5=1)

op_type = 'LeadRubberX'

class o3seespy.command.element.bearing.MultipleShearSpring(osi, ele_nodes, n_spring, mat=None, lim: Optional[float] = None, mass: Optional[float] = None, orient=None)

Bases: ElementBase

The MultipleShearSpring Element Class

This command is used to construct a multipleShearSpring (MSS) element object, which is defined by two nodes. This element consists of a series of identical shear springs arranged radially to represent the isotropic behavior in the local y-z plane.

Initial method for MultipleShearSpring

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• n_spring (int) – Number of springs

• mat (obj, optional) – Object associated with previously-defined uniaxial_material object

• lim (float, optional) – Minimum deformation to calculate equivalent coefficient (see note 1)

• mass (float, optional) – Element mass

• orient (None, optional) –

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=3, ndf=6)
>>> coords = [[0, 0, 0], [1, 0, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat = o3.uniaxial_material.Elastic(osi, 1.0)
>>> o3.element.MultipleShearSpring(osi, ele_nodes=ele_nodes, n_spring=1, mat=mat, lim=1.0, mass=1.0, orient=None)

op_type = 'multipleShearSpring'

class o3seespy.command.element.bearing.RJWatsonEqsBearing2D(osi, ele_nodes, frn_mdl, k_init, p_mat=None, vy_mat=None, mz_mat=None, do_rayleigh=False, max_iter: Optional[int] = None, tol: Optional[float] = None, orient=None, mass: Optional[float] = None, shear_dist: Optional[float] = None)

Bases: ElementBase

The RJWatsonEqsBearing2D Element Class

This command is used to construct a RJWatsonEqsBearing element object, which is defined by two nodes. The iNode represents the masonry plate and the jNode represents the sliding surface plate. The element can have zero length or the appropriate bearing height. The bearing has unidirectional (2D) or coupled (3D) friction properties (with post-yield stiffening due to the mass-energy-regulator (MER) springs) for the shear deformations, and force-deformation behaviors defined by UniaxialMaterials in the remaining two (2D) or four (3D) directions. To capture the uplift behavior of the bearing, the user-specified UniaxialMaterial in the axial direction is modified for no-tension behavior. By default (sDratio = 1.0) P-Delta moments are entirely transferred to the sliding surface (jNode). It is important to note that rotations of the sliding surface (rotations at the jNode) affect the shear behavior of the bearing. To avoid the introduction of artificial viscous damping in the isolation system (sometimes referred to as “damping leakage in the isolation system”), the bearing element does not contribute to the Rayleigh damping by default. If the element has non-zero length, the local x-axis is determined from the nodal geometry unless the optional x-axis vector is specified in which case the nodal geometry is ignored and the user-defined orientation is utilized.

For a two-dimensional problem

Initial method for RJWatsonEqsBearing2D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• frn_mdl (obj) – Object associated with previously-defined frictionmodel

• k_init (float) – Initial stiffness of sliding friction component in local shear direction

• p_mat (obj, optional) – Object associated with previously-defined uniaxial_material in axial direction

• vy_mat (obj, optional) – Object associated with previously-defined uniaxial_material in shear direction along local y-axis (mer spring behavior not including friction)

• mz_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local z-axis

• do_rayleigh (bool) – To include rayleigh damping from the bearing (optional, default = no rayleigh damping contribution)

• max_iter (int, optional) – Maximum number of iterations to undertake to satisfy element equilibrium (optional, default = 20)

• tol (float, optional) – Convergence tolerance to satisfy element equilibrium (optional, default = 1e-8)

• orient (None, optional) –

• mass (float, optional) – Element mass (optional, default = 0.0)

• shear_dist (float, optional) – Shear distance from inode as a fraction of the element length (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> p_mat = o3.uniaxial_material.Elastic(osi, 1, 1)
>>> vy_mat = o3.uniaxial_material.Elastic(osi, 1, 1)
>>> mz_mat = o3.uniaxial_material.Elastic(osi, 1, 1)
>>> frn_mdl = o3.friction_model.Coulomb(osi, mu=1.0)
>>> o3.element.RJWatsonEqsBearing2D(osi, ele_nodes=ele_nodes, frn_mdl=frn_mdl, k_init=1.0, p_mat=p_mat, vy_mat=vy_mat,
>>>                                 mz_mat=mz_mat, do_rayleigh=False, max_iter=1, tol=1.0, orient=None, mass=1.0,
>>>                                 shear_dist=1.0)

op_type = 'RJWatsonEqsBearing'

class o3seespy.command.element.bearing.RJWatsonEqsBearing3D(osi, ele_nodes, frn_mdl, k_init, p_mat=None, vy_mat=None, vz_mat=None, t_mat=None, my_mat=None, mz_mat=None, do_rayleigh=False, max_iter: Optional[int] = None, tol: Optional[float] = None, orient=None, mass: Optional[float] = None, shear_dist: Optional[float] = None)

Bases: ElementBase

The RJWatsonEqsBearing3D Element Class

This command is used to construct a RJWatsonEqsBearing element object, which is defined by two nodes. The iNode represents the masonry plate and the jNode represents the sliding surface plate. The element can have zero length or the appropriate bearing height. The bearing has unidirectional (2D) or coupled (3D) friction properties (with post-yield stiffening due to the mass-energy-regulator (MER) springs) for the shear deformations, and force-deformation behaviors defined by UniaxialMaterials in the remaining two (2D) or four (3D) directions. To capture the uplift behavior of the bearing, the user-specified UniaxialMaterial in the axial direction is modified for no-tension behavior. By default (sDratio = 1.0) P-Delta moments are entirely transferred to the sliding surface (jNode). It is important to note that rotations of the sliding surface (rotations at the jNode) affect the shear behavior of the bearing. To avoid the introduction of artificial viscous damping in the isolation system (sometimes referred to as “damping leakage in the isolation system”), the bearing element does not contribute to the Rayleigh damping by default. If the element has non-zero length, the local x-axis is determined from the nodal geometry unless the optional x-axis vector is specified in which case the nodal geometry is ignored and the user-defined orientation is utilized.

For a three-dimensional problem

Initial method for RJWatsonEqsBearing3D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• frn_mdl (obj) – Object associated with previously-defined frictionmodel

• k_init (float) – Initial stiffness of sliding friction component in local shear direction

• p_mat (obj, optional) – Object associated with previously-defined uniaxial_material in axial direction

• vy_mat (obj, optional) – Object associated with previously-defined uniaxial_material in shear direction along local y-axis (mer spring behavior not including friction)

• vz_mat (obj, optional) – Object associated with previously-defined uniaxial_material in shear direction along local z-axis (mer spring behavior not including friction)

• t_mat (obj, optional) – Object associated with previously-defined uniaxial_material in torsional direction

• my_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local y-axis

• mz_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local z-axis

• do_rayleigh (bool) – To include rayleigh damping from the bearing (optional, default = no rayleigh damping contribution)

• max_iter (int, optional) – Maximum number of iterations to undertake to satisfy element equilibrium (optional, default = 20)

• tol (float, optional) – Convergence tolerance to satisfy element equilibrium (optional, default = 1e-8)

• orient (None, optional) –

• mass (float, optional) – Element mass (optional, default = 0.0)

• shear_dist (float, optional) – Shear distance from inode as a fraction of the element length (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=3, ndf=6)
>>> coords = [[0, 0, 0], [0, 1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> p_mat = o3.uniaxial_material.Elastic(osi, 1, 1)
>>> vy_mat = o3.uniaxial_material.Elastic(osi, 1, 1)
>>> vz_mat = o3.uniaxial_material.Elastic(osi, 1, 1)
>>> t_mat = o3.uniaxial_material.Elastic(osi, 1, 1)
>>> my_mat = o3.uniaxial_material.Elastic(osi, 1, 1)
>>> mz_mat = o3.uniaxial_material.Elastic(osi, 1, 1)
>>> orient_vals = [1, 0, 0]
>>> frn_mdl = o3.friction_model.Coulomb(osi, mu=1.0)
>>> o3.element.RJWatsonEqsBearing3D(osi, ele_nodes=ele_nodes, frn_mdl=frn_mdl, k_init=1.0, p_mat=p_mat,
>>>                                 vy_mat=vy_mat, vz_mat=vz_mat, t_mat=t_mat, my_mat=my_mat, mz_mat=mz_mat,
>>>                                 do_rayleigh=False, max_iter=1, tol=1.0, orient=orient_vals, mass=1.0, shear_dist=1.0)

op_type = 'RJWatsonEqsBearing'

class o3seespy.command.element.bearing.SingleFPBearing2D(osi, ele_nodes, frn_mdl, reff, k_init, p_mat=None, mz_mat=None, do_rayleigh=False, max_iter: Optional[int] = None, tol: Optional[float] = None, orient=None, mass: Optional[float] = None, shear_dist: Optional[float] = None)

Bases: ElementBase

The SingleFPBearing2D Element Class

This command is used to construct a singleFPBearing element object, which is defined by two nodes. The iNode represents the concave sliding surface and the jNode represents the articulated slider. The element can have zero length or the appropriate bearing height. The bearing has unidirectional (2D) or coupled (3D) friction properties (with post-yield stiffening due to the concave sliding surface) for the shear deformations, and force-deformation behaviors defined by UniaxialMaterials in the remaining two (2D) or four (3D) directions. To capture the uplift behavior of the bearing, the user-specified UniaxialMaterial in the axial direction is modified for no-tension behavior. By default (sDratio = 0.0) P-Delta moments are entirely transferred to the concave sliding surface (iNode). It is important to note that rotations of the concave sliding surface (rotations at the iNode) affect the shear behavior of the bearing. To avoid the introduction of artificial viscous damping in the isolation system (sometimes referred to as “damping leakage in the isolation system”), the bearing element does not contribute to the Rayleigh damping by default. If the element has non-zero length, the local x-axis is determined from the nodal geometry unless the optional x-axis vector is specified in which case the nodal geometry is ignored and the user-defined orientation is utilized.

For a two-dimensional problem

Initial method for SingleFPBearing2D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• frn_mdl (obj) – Object associated with previously-defined frictionmodel

• reff (float) – Effective radius of concave sliding surface

• k_init (float) – Initial elastic stiffness in local shear direction

• p_mat (obj, optional) – Object associated with previously-defined uniaxial_material in axial direction

• mz_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local z-axis

• do_rayleigh (bool) – To include rayleigh damping from the bearing (optional, default = no rayleigh damping contribution)

• max_iter (int, optional) – Maximum number of iterations to undertake to satisfy element equilibrium (optional, default = 20)

• tol (float, optional) – Convergence tolerance to satisfy element equilibrium (optional, default = 1e-8)

• orient (None, optional) –

• mass (float, optional) – Element mass (optional, default = 0.0)

• shear_dist (float, optional) – Shear distance from inode as a fraction of the element length (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> p_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> mz_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> frn1 = o3.friction_model.Coulomb(osi, mu=1.0)
>>> o3.element.SingleFPBearing2D(osi, ele_nodes=ele_nodes, frn_mdl=frn1, reff=1.0, k_init=1.0, p_mat=p_mat,
>>>                              mz_mat=mz_mat, do_rayleigh=False, max_iter=1, tol=1.0, orient=None,
>>>                              mass=1.0, shear_dist=1.0)

op_type = 'singleFPBearing'

class o3seespy.command.element.bearing.SingleFPBearing3D(osi, ele_nodes, frn_mdl, reff, k_init, p_mat=None, t_mat=None, my_mat=None, mz_mat=None, do_rayleigh=False, max_iter: Optional[int] = None, tol: Optional[float] = None, orient=None, mass: Optional[float] = None, shear_dist: Optional[float] = None)

Bases: ElementBase

The SingleFPBearing3D Element Class

This command is used to construct a singleFPBearing element object, which is defined by two nodes. The iNode represents the concave sliding surface and the jNode represents the articulated slider. The element can have zero length or the appropriate bearing height. The bearing has unidirectional (2D) or coupled (3D) friction properties (with post-yield stiffening due to the concave sliding surface) for the shear deformations, and force-deformation behaviors defined by UniaxialMaterials in the remaining two (2D) or four (3D) directions. To capture the uplift behavior of the bearing, the user-specified UniaxialMaterial in the axial direction is modified for no-tension behavior. By default (sDratio = 0.0) P-Delta moments are entirely transferred to the concave sliding surface (iNode). It is important to note that rotations of the concave sliding surface (rotations at the iNode) affect the shear behavior of the bearing. To avoid the introduction of artificial viscous damping in the isolation system (sometimes referred to as “damping leakage in the isolation system”), the bearing element does not contribute to the Rayleigh damping by default. If the element has non-zero length, the local x-axis is determined from the nodal geometry unless the optional x-axis vector is specified in which case the nodal geometry is ignored and the user-defined orientation is utilized.

For a three-dimensional problem

Initial method for SingleFPBearing3D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• frn_mdl (obj) – Object associated with previously-defined frictionmodel

• reff (float) – Effective radius of concave sliding surface

• k_init (float) – Initial elastic stiffness in local shear direction

• p_mat (obj, optional) – Object associated with previously-defined uniaxial_material in axial direction

• t_mat (obj, optional) – Object associated with previously-defined uniaxial_material in torsional direction

• my_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local y axis

• mz_mat (obj, optional) – Object associated with previously-defined uniaxial_material in moment direction around local z-axis

• do_rayleigh (bool) – To include rayleigh damping from the bearing (optional, default = no rayleigh damping contribution)

• max_iter (int, optional) – Maximum number of iterations to undertake to satisfy element equilibrium (optional, default = 20)

• tol (float, optional) – Convergence tolerance to satisfy element equilibrium (optional, default = 1e-8)

• orient (None, optional) –

• mass (float, optional) – Element mass (optional, default = 0.0)

• shear_dist (float, optional) – Shear distance from inode as a fraction of the element length (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=3, ndf=6)
>>> coords = [[0, 0, 0], [0, 1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> p_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> mz_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> t_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> my_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> frn1 = o3.friction_model.Coulomb(osi, mu=1.0)
>>> orient_vals = [1, 0, 0]
>>> o3.element.SingleFPBearing3D(osi, ele_nodes=ele_nodes, frn_mdl=frn1, reff=1.0, k_init=1.0, p_mat=p_mat, t_mat=t_mat,
>>>                              my_mat=my_mat, mz_mat=mz_mat, do_rayleigh=False, max_iter=None, tol=None,
>>>                              orient=orient_vals, mass=1.0, shear_dist=1.0)

op_type = 'singleFPBearing'

class o3seespy.command.element.bearing.TFP(osi, ele_nodes, r1, r2, r3, r4, db1, db2, db3, db4, d1, d2, d3, d4, mu1, mu2, mu3, mu4, h1, h2, h3, h4, h0, col_load, big_k=None)

Bases: ElementBase

The TFP Element Class

This command is used to construct a Triple Friction Pendulum Bearing element object, which is defined by two nodes. The element can have zero length or the appropriate bearing height. The bearing has unidirectional (2D) or coupled (3D) friction properties (with post-yield stiffening due to the concave sliding surface) for the shear deformations, and force-deformation behaviors defined by UniaxialMaterials in the remaining two (2D) or four (3D) directions. To capture the uplift behavior of the bearing, the user-specified UniaxialMaterial in the axial direction is modified for no-tension behavior. P-Delta moments are entirely transferred to the concave sliding surface (iNode). It is important to note that rotations of the concave sliding surface (rotations at the iNode) affect the shear behavior of the bearing. If the element has non-zero length, the local x-axis is determined from the nodal geometry unless the optional x-axis vector is specified in which case the nodal geometry is ignored and the user-defined orientation is utilized.

Initial method for TFP

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• r1 (float) – Radius of inner bottom sliding surface

• r2 (float) – Radius of inner top sliding surface

• r3 (float) – Radius of outer bottom sliding surface

• r4 (float) – Radius of outer top sliding surface

• db1 (float) – Diameter of inner bottom sliding surface

• db2 (float) – Diameter of inner top sliding surface

• db3 (float) – Diameter of outer bottom sliding surface

• db4 (float) – Diameter of outer top sliding surface

• d1 (float) – Diameter of inner slider

• d2 (float) – Diameter of inner slider

• d3 (float) – Diameter of outer bottom slider

• d4 (float) – Diameter of outer top slider

• mu1 (float) – Friction coefficient of inner bottom sliding surface

• mu2 (float) – Friction coefficient of inner top sliding surface

• mu3 (float) – Friction coefficient of outer bottom sliding surface

• mu4 (float) – Friction coefficient of outer top sliding surface

• h1 (float) – Height from inner bottom sliding surface to center of bearing

• h2 (float) – Height from inner top sliding surface to center of bearing

• h3 (float) – Height from outer bottom sliding surface to center of bearing

• h4 (float) – Height from inner top sliding surface to center of bearing

• h0 (float) – Total height of bearing

• col_load (float) – Initial axial load on bearing (only used for first time step then load come from model)

• big_k (float) – Optional, stiffness of spring in vertical dirn (dof 2 if ndm= 2, dof 3 if ndm = 3) (default=1.0e15)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> o3.element.TFP(osi, ele_nodes=ele_nodes,
>>>                r1=1.0, r2=1.0, r3=1.0, r4=1.0,
>>>                db1=1.0, db2=1.0, db3=1.0, db4=1.0,
>>>                d1=1.0, d2=1.0, d3=1.0, d4=1.0,
>>>                mu1=0.3, mu2=0.4, mu3=0.5, mu4=0.5,
>>>                h1=1.0, h2=1.0, h3=1.0, h4=1.0,
>>>                h0=1.0, col_load=1.0, big_k=None)

op_type = 'TFP'

class o3seespy.command.element.bearing.TripleFrictionPendulum(osi, ele_nodes, frn1, frn2, frn3, vert_mat, rot_z_mat, rot_x_mat, rot_y_mat, l1, l2, l3, d1, d2, d3, big_w, uy, kvt, min_fv, tol)

Bases: ElementBase

The TripleFrictionPendulum Element Class

Initial method for TripleFrictionPendulum

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• frn1 (obj) – = objects associated with previously-defined frictionmodels at the three sliding interfaces

• frn2 (obj) – = objects associated with previously-defined frictionmodels at the three sliding interfaces

• frn3 (obj) – = objects associated with previously-defined frictionmodels at the three sliding interfaces

• vert_mat (obj) – = pre-defined material object for compression behavior of the bearing

• rot_z_mat (obj) – = pre-defined material objects for rotational behavior about 3-axis, 1-axis and 2-axis, respectively.

• rot_x_mat (obj) – = pre-defined material objects for rotational behavior about 3-axis, 1-axis and 2-axis, respectively.

• rot_y_mat (obj) – = pre-defined material objects for rotational behavior about 3-axis, 1-axis and 2-axis, respectively.

• l1 (float) – = effective radii. li = r_i - h_i (see figure 1)

• l2 (float) – = effective radii. li = r_i - h_i (see figure 1)

• l3 (float) – = effective radii. li = r_i - h_i (see figure 1)

• d1 (float) –

  = displacement limits of pendulums (figure 1). displacement limit of the bearing is 2 d1 + d2 +

  d3 + l1. d3/ l3 - l1. d2/ l2

• d2 (float) –

  = displacement limits of pendulums (figure 1). displacement limit of the bearing is 2 d1 + d2 +

  d3 + l1. d3/ l3 - l1. d2/ l2

• d3 (float) –

  = displacement limits of pendulums (figure 1). displacement limit of the bearing is 2 d1 + d2 +

  d3 + l1. d3/ l3 - l1. d2/ l2

• big_w (float) – = axial force used for the first trial of the first analysis step.

• uy (float) – = lateral displacement where sliding of the bearing starts. recommended value = 0.25 to 1 mm. a smaller value may cause convergence problem.

• kvt (float) – = tension stiffness k_vt of the bearing.

• min_fv (None) –

• tol (float) – = relative tolerance for checking the convergence of the element. recommended value = 1.e-10 to 1.e-3.

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> frn1 = o3.friction_model.Coulomb(osi, mu=1.0)
>>> frn2 = o3.friction_model.Coulomb(osi, mu=1.0)
>>> frn3 = o3.friction_model.Coulomb(osi, mu=1.0)
>>> vert_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> rot_z_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> rot_x_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> rot_y_mat = o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None)
>>> o3.element.TripleFrictionPendulum(osi, ele_nodes=ele_nodes, frn1=frn1, frn2=frn2, frn3=frn3, vert_mat=vert_mat,
>>>                                   rot_z_mat=rot_z_mat, rot_x_mat=rot_x_mat, rot_y_mat=rot_y_mat, l1=1.0, l2=1.0,
>>>                                   l3=1.0, d1=1.0, d2=1.0, d3=1.0, big_w=1.0, uy=1.0, kvt=1.0, min_fv=None, tol=1.0)

op_type = 'TripleFrictionPendulum'

class o3seespy.command.element.bearing.YamamotoBiaxialHDRcoRS(osi, ele_nodes, tp, d_do, d_di, hr, cr, cs, orient: Optional[list] = None, mass: Optional[float] = None)

Bases: ElementBase

The YamamotoBiaxialHDRcoRS Element Class

This command is used to construct a YamamotoBiaxialHDR element object, which is defined by two nodes. This element can be used to represent the isotropic behavior of high-damping rubber bearing in the local y-z plane.

Initial method for YamamotoBiaxialHDRcoRS

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• tp (int) – Compound type = 1 : x0.6r manufactured by bridgestone corporation.

• d_do (float) – Outer diameter [m]

• d_di (float) – Bore diameter [m]

• hr (float) – Total thickness of rubber layer [m] optional data

• cr (float) – Coefficients for shear stress components of tau_r and tau_s

• cs (float) – Coefficients for shear stress components of tau_r and tau_s

• orient (list, optional) –

• mass (float, optional) – Element mass [kg]

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> o3.element.YamamotoBiaxialHDRcoRS(osi, ele_nodes=ele_nodes, tp=1, d_do=1.0, d_di=1.0, hr=1.0, cr=1.0, cs=1.0, orient=[0.0, 0.0], mass=1.0)

op_type = 'YamamotoBiaxialHDR'

Brick

class o3seespy.command.element.brick.BbarBrick(osi, ele_nodes, mat, b1, b2, b3)

Bases: ElementBase

The BbarBrick Element Class

This command is used to construct an eight-node mixed volume/pressure brick element object, which uses a trilinear isoparametric formulation.

Initial method for BbarBrick

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of eight element nodes in bottom and top faces and in counter-clockwise order

• mat (obj) – Object of ndmaterial

• b1 (float) – Body forces in global x,y,z directions (defined as a load, not as an accel, see o3seespy-examples)

• b2 (float) – Body forces in global x,y,z directions

• b3 (float) – Body forces in global x,y,z directions

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=3)
>>> coords = [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> o3.element.BbarBrick(osi, ele_nodes=ele_nodes, mat=mat, b1=1.0, b2=1.0, b3=1.0)

op_type = 'bbarBrick'

class o3seespy.command.element.brick.N20NodeBrick(osi, ele_nodes, mat, bf1, bf2, bf3, mass_den)

Bases: ElementBase

The N20NodeBrick Element Class

The element is used to construct a twenty-node three dimensional element object

Initial method for N20NodeBrick

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of twenty element nodes, input order is shown in notes below

• mat (obj) – Material object associated with previsouly-defined ndmaterial object

• bf1 (float) – Body force in the direction of global coordinates x, y and z

• bf2 (float) – Body force in the direction of global coordinates x, y and z

• bf3 (float) – Body force in the direction of global coordinates x, y and z

• mass_den (float) – Mass density (mass/volume)

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=3, ndf=6)
>>> coords = [[0, 0, 0], [-1, 0, 0], [-1, -1, 0], [0, -1, 0],
>>>           [0, 0, -1], [-1, 0, -1], [-1, -1, -1], [0, -1, -1],
>>>           [-0.5, 0, 0], [-1, -0.5, 0], [-0.5, -1, 0], [0, -0.5, 0],
>>>           [-0.5, 0, -1], [-1, -0.5, -1], [-0.5, -1, -1], [0, -0.5, -1],
>>>           [0, 0, -0.5], [-1, 0, -0.5], [-1, -1, -0.5], [0, -1, -0.5],
>>>           ]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> o3.element.N20NodeBrick(osi, ele_nodes=ele_nodes, mat=mat, bf1=1.0, bf2=1.0, bf3=1.0, mass_den=1.0)

op_type = '20NodeBrick'

class o3seespy.command.element.brick.SSPbrick(osi, ele_nodes, mat, b1, b2, b3)

Bases: ElementBase

The SSPbrick Element Class

This command is used to construct a SSPbrick element object.

Initial method for SSPbrick

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of eight element nodes in bottom and top faces and in counter-clockwise order

• mat (obj) – Unique integer object associated with previously-defined ndmaterial object

• b1 (float) – Constant body forces in global x-, y-, and z-directions, respectively (optional, default = 0.0)

• b2 (float) – Constant body forces in global x-, y-, and z-directions, respectively (optional, default = 0.0)

• b3 (float) – Constant body forces in global x-, y-, and z-directions, respectively (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=3)
>>> coords = [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> o3.element.SSPbrick(osi, ele_nodes=ele_nodes, mat=mat, b1=1.0, b2=1.0, b3=1.0)

op_type = 'SSPbrick'

class o3seespy.command.element.brick.StdBrick(osi, ele_nodes, mat, b1, b2, b3)

Bases: ElementBase

The StdBrick Element Class

This element is used to construct an eight-node brick element object, which uses a trilinear isoparametric formulation.

Initial method for StdBrick

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of eight element nodes in bottom and top faces and in counter-clockwise order

• mat (obj) – Object of ndmaterial

• b1 (float) – Body forces in global x,y,z directions

• b2 (float) – Body forces in global x,y,z directions

• b3 (float) – Body forces in global x,y,z directions

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=3)
>>> coords = [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> o3.element.StdBrick(osi, ele_nodes=ele_nodes, mat=mat, b1=1.0, b2=1.0, b3=1.0)

op_type = 'stdBrick'

Cable

class o3seespy.command.element.cable.CatenaryCable(osi, i_node, j_node, weight, big_e, big_a, l0, alpha, temperature_change, rho, error_tol, nsubsteps, mass_type)

Bases: ElementBase

The CatenaryCable Element Class

This command is used to construct a catenary cable element object.

Initial method for CatenaryCable

Parameters

• osi (o3seespy.OpenSeesInstance) –

• i_node (obj) – End nodes (3 dof per node)

• j_node (obj) – End nodes (3 dof per node)

• weight (float) – Undefined

• big_e (float) – Elastic modulus of the cable material

• big_a (float) – Cross-sectional area of element

• l0 (float) – Unstretched length of the cable

• alpha (float) – Coefficient of thermal expansion

• temperature_change (float) – Temperature change for the element

• rho (float) – Mass per unit length

• error_tol (float) – Allowed tolerance for within-element equilbrium (newton-rhapson iterations)

• nsubsteps (int) – Number of within-element substeps into which equilibrium iterations are subdivided (not number of steps to convergence)

• mass_type (int) – Mass matrix model to use (masstype = 0 lumped mass matrix, masstype = 1 rigid-body mass matrix (in development))

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> i_node = o3.node.Node(osi, 0.0, 0.0)
>>> j_node = o3.node.Node(osi, 0.0, 1.0)
>>> o3.element.CatenaryCable(osi, i_node=i_node, j_node=j_node, weight=1.0, big_e=1.0, big_a=1.0, l0=1.0, alpha=1.0, temperature_change=1.0, rho=1.0, error_tol=1.0, nsubsteps=1, mass_type=1)

op_type = 'CatenaryCable'

Contact

class o3seespy.command.element.contact.BeamContact2D(osi, i_node, j_node, s_node, l_node, mat, width, g_tol, f_tol, c_flag)

Bases: ElementBase

The BeamContact2D Element Class

This command is used to construct a BeamContact2D element object.

Initial method for BeamContact2D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• i_node (obj) – Master nodes (-ndm 2 -ndf 3)

• j_node (obj) – Master nodes (-ndm 2 -ndf 3)

• s_node (obj) – Slave node (-ndm 2 -ndf 2)

• l_node (obj) – Lagrange multiplier node (-ndm 2 -ndf 2)

• mat (obj) – Unique integer object associated with previously-defined ndmaterial object

• width (float) – The width of the wall represented by the beam element in plane strain

• g_tol (float) – Gap tolerance

• f_tol (float) – Force tolerance

• c_flag (int) – Optional initial contact flag

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> i_node = o3.node.Node(osi, 0.0, 0.0)
>>> j_node = o3.node.Node(osi, 0.0, 1.0)
>>> s_node = o3.node.Node(osi, 0.0, 1.0)
>>> l_node = o3.node.Node(osi, 0.0, 1.0)
>>> mat = o3.nd_material.ContactMaterial2D(osi, mu=1.0, g_mod=1.0, c=1.0, t=1.0)
>>> o3.element.BeamContact2D(osi, i_node=i_node, j_node=j_node, s_node=s_node, l_node=l_node, mat=mat, width=1.0,
>>>                          g_tol=1.0, f_tol=1.0, c_flag=1)

op_type = 'BeamContact2D'

class o3seespy.command.element.contact.BeamContact3D(osi, i_node, j_node, c_node, l_node, radius, crd_transf, mat, g_tol, f_tol, c_flag)

Bases: ElementBase

The BeamContact3D Element Class

This command is used to construct a BeamContact3D element object.

Initial method for BeamContact3D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• i_node (obj) – Master nodes (-ndm 3 -ndf 6)

• j_node (obj) – Master nodes (-ndm 3 -ndf 6)

• c_node (obj) – Constrained node (-ndm 3 -ndf 3)

• l_node (obj) – Lagrange multiplier node (-ndm 3 -ndf 3)

• radius (float) – Constant radius of circular beam associated with beam element

• crd_transf (obj) – Unique integer object associated with previously-defined geometrictransf object

• mat (obj) – Unique integer object associated with previously-defined ndmaterial object

• g_tol (float) – Gap tolerance

• f_tol (float) – Force tolerance

• c_flag (int) – Optional initial contact flag

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=3, ndf=6)
>>> i_node = o3.node.Node(osi, 0.0, 0.0, 0.0)
>>> j_node = o3.node.Node(osi, 0.0, 1.0, 0.0)
>>> osi.reset_model_params(ndm=3, ndf=3)
>>> c_node = o3.node.Node(osi, 0.0, 1.0, 0.0)
>>> l_node = o3.node.Node(osi, 0.0, 1.0, 0.0)
>>> osi.reset_model_params(ndm=3, ndf=6)
>>> mat = o3.nd_material.ContactMaterial3D(osi, mu=1.0, g_mod=1.0, c=1.0, t=1.0)
>>> crd_transf = o3.geom_transf.Linear3D(osi, vecxz=[1.0, 1.0], d_i=[1.0, 1.0], d_j=[1.0, 1.0])
>>> o3.element.BeamContact3D(osi, i_node=i_node, j_node=j_node, c_node=c_node, l_node=l_node, radius=1.0,
>>>                          crd_transf=crd_transf, mat=mat, g_tol=1.0, f_tol=1.0, c_flag=1)

op_type = 'BeamContact3D'

class o3seespy.command.element.contact.BeamEndContact3D(osi, i_node, j_node, c_node, l_node, radius, g_tol, f_tol, c_flag)

Bases: ElementBase

The BeamEndContact3D Element Class

This command is used to construct a BeamEndContact3D element object.

Initial method for BeamEndContact3D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• i_node (obj) – Master node from the beam (-ndm 3 -ndf 6)

• j_node (obj) – The remaining node on the beam element with inode (-ndm 3 -ndf 6)

• c_node (obj) – Constrained node (-ndm 3 -ndf 3)

• l_node (obj) – Lagrange multiplier node (-ndm 3 -ndf 3)

• radius (float) – Radius of circular beam associated with beam element

• g_tol (float) – Gap tolerance

• f_tol (float) – Force tolerance

• c_flag (float) – Optional initial contact flag

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=3, ndf=6)
>>> i_node = o3.node.Node(osi, 0.0, 0.0, 0.0)
>>> j_node = o3.node.Node(osi, 0.0, 1.0, 0.0)
>>> osi.reset_model_params(ndm=3, ndf=3)
>>> c_node = o3.node.Node(osi, 0.0, 1.0, 0.0)
>>> l_node = o3.node.Node(osi, 0.0, 1.0, 0.0)
>>> o3.element.BeamEndContact3D(osi, i_node=i_node, j_node=j_node, c_node=c_node, l_node=l_node, radius=1.0,
>>>                             g_tol=1.0, f_tol=1.0, c_flag=1.0)

op_type = 'BeamEndContact3D'

class o3seespy.command.element.contact.SimpleContact2D(osi, i_node, j_node, c_node, l_node, mat, g_tol, f_tol)

Bases: ElementBase

The SimpleContact2D Element Class

This command is used to construct a SimpleContact2D element object.

Initial method for SimpleContact2D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• i_node (obj) – Retained nodes (-ndm 2 -ndf 2)

• j_node (obj) – Retained nodes (-ndm 2 -ndf 2)

• c_node (obj) – Constrained node (-ndm 2 -ndf 2)

• l_node (obj) – Lagrange multiplier node (-ndm 2 -ndf 2)

• mat (obj) – Unique integer object associated with previously-defined ndmaterial object

• g_tol (float) – Gap tolerance

• f_tol (float) – Force tolerance

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2, ndf=2)
>>> i_node = o3.node.Node(osi, 0.0, 0.0)
>>> j_node = o3.node.Node(osi, 0.0, 1.0)
>>> c_node = o3.node.Node(osi, 0.0, 0.0)
>>> l_node = o3.node.Node(osi, 0.0, 1.0)
>>> mat = o3.nd_material.ContactMaterial2D(osi, mu=1.0, g_mod=1.0, c=1.0, t=1.0)
>>> o3.element.SimpleContact2D(osi, i_node=i_node, j_node=j_node, c_node=c_node, l_node=l_node, mat=mat,
>>>                            g_tol=1.0, f_tol=1.0)

op_type = 'SimpleContact2D'

class o3seespy.command.element.contact.SimpleContact3D(osi, i_node, j_node, k_node, l_node, c_node, lagr_node, mat, g_tol, f_tol)

Bases: ElementBase

The SimpleContact3D Element Class

This command is used to construct a SimpleContact3D element object.

Initial method for SimpleContact3D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• i_node (obj) – Master nodes (-ndm 3 -ndf 3)

• j_node (obj) – Master nodes (-ndm 3 -ndf 3)

• k_node (obj) – Master nodes (-ndm 3 -ndf 3)

• l_node (obj) – Master nodes (-ndm 3 -ndf 3)

• c_node (obj) – Constrained node (-ndm 3 -ndf 3)

• lagr_node (obj) – Lagrange multiplier node (-ndm 3 -ndf 3)

• mat (obj) – Unique integer object associated with previously-defined ndmaterial object

• g_tol (float) – Gap tolerance

• f_tol (float) – Force tolerance

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=3, ndf=3)
>>> i_node = o3.node.Node(osi, 0.0, 0.0, 0.0)
>>> j_node = o3.node.Node(osi, 0.0, 1.0, 0.0)
>>> k_node = o3.node.Node(osi, 0.0, 0.0, 0.0)
>>> c_node = o3.node.Node(osi, 0.0, 0.0, 0.0)
>>> l_node = o3.node.Node(osi, 0.0, 1.0, 0.0)
>>> lagr_node = o3.node.Node(osi, 0.0, 1.0, 0.0)
>>> mat = o3.nd_material.ContactMaterial3D(osi, mu=1.0, g_mod=1.0, c=1.0, t=1.0)
>>> o3.element.SimpleContact3D(osi, i_node=i_node, j_node=j_node, k_node=k_node, l_node=l_node, c_node=c_node,
>>>                            lagr_node=lagr_node, mat=mat, g_tol=1.0, f_tol=1.0)

op_type = 'SimpleContact3D'

Joint

class o3seespy.command.element.joint.BeamColumnJoint(osi, ele_nodes, mat1, mat2, mat3, mat4, mat5, mat6, mat7, mat8, mat9, mat10, mat11, mat12, mat13, ele_height_fac=1.0, ele_width_fac=1.0)

Bases: ElementBase

The BeamColumnJoint Element Class

This command is used to construct a two-dimensional beam-column-joint element object. The element may be used with both two-dimensional and three-dimensional structures; however, load is transferred only in the plane of the element.

Initial method for BeamColumnJoint

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes

• mat1 (obj) – Uniaxial material object for left bar-slip spring at node 1

• mat2 (obj) – Uniaxial material object for right bar-slip spring at node 1

• mat3 (obj) – Uniaxial material object for interface-shear spring at node 1

• mat4 (obj) – Uniaxial material object for lower bar-slip spring at node 2

• mat5 (obj) – Uniaxial material object for upper bar-slip spring at node 2

• mat6 (obj) – Uniaxial material object for interface-shear spring at node 2

• mat7 (obj) – Uniaxial material object for left bar-slip spring at node 3

• mat8 (obj) – Uniaxial material object for right bar-slip spring at node 3

• mat9 (obj) – Uniaxial material object for interface-shear spring at node 3

• mat10 (obj) – Uniaxial material object for lower bar-slip spring at node 4

• mat11 (obj) – Uniaxial material object for upper bar-slip spring at node 4

• mat12 (obj) – Uniaxial material object for interface-shear spring at node 4

• mat13 (obj) – Uniaxial material object for shear-panel

• ele_height_fac (float, optional) – Floating point value (as a ratio to the total height of the element) to be considered for determination of the distance in between the tension-compression couples (optional, default: 1.0)

• ele_width_fac (float, optional) – Floating point value (as a ratio to the total width of the element) to be considered for determination of the distance in between the tension-compression couples (optional, default: 1.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> mats = [o3.uniaxial_material.Elastic(osi, e_mod=1.0, eta=0.0, eneg=None) for x in range(13)]
>>> o3.element.BeamColumnJoint(osi, ele_nodes, *mats, ele_height_fac=1.0, ele_width_fac=1.0)

op_type = 'beamColumnJoint'

class o3seespy.command.element.joint.ElasticTubularJoint(osi, ele_nodes, brace_diameter, brace_angle, big_e, chord_diameter, chord_thickness, chord_angle)

Bases: ElementBase

The ElasticTubularJoint Element Class

This command is used to construct an ElasticTubularJoint element object, which models joint flexibility of tubular joints in two dimensional analysis of any structure having tubular joints.

Initial method for ElasticTubularJoint

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• brace_diameter (float) – Outer diameter of brace

• brace_angle (float) – Angle between brace and chord axis 0 < brace_angle < 90

• big_e (float) – Young’s modulus

• chord_diameter (float) – Outer diameter of chord

• chord_thickness (float) – Thickness of chord

• chord_angle (float) – Angle between chord axis and global x-axis 0 < chord_angle < 180

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> o3.element.ElasticTubularJoint(osi, ele_nodes=ele_nodes, brace__diameter=1.0, brace__angle=1.0, big_e=1.0, chord__diameter=1.0, chord__thickness=1.0, chord__angle=1.0)

op_type = 'ElasticTubularJoint'

class o3seespy.command.element.joint.Joint2D(osi, ele_nodes, mat1, mat2, mat3, mat4, mat_c, lrg_dsp, dmg, dmg_vals=None)

Bases: ElementBase

The Joint2D Element Class

This command is used to construct a two-dimensional beam-column-joint element object. The two dimensional beam-column joint is idealized as a parallelogram shaped shear panel with adjacent elements connected to its mid-points. The midpoints of the parallelogram are referred to as external nodes. These nodes are the only analysis components that connect the joint element to the surrounding structure.

Initial method for Joint2D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of five element nodes = [nd1,nd2,nd3,nd4,ndc]. ndc is the central node of beam-column joint. (the object ndc is used to generate the internal node, thus, the node should not exist in the domain or be used by any other node)

• mat1 (int) – Uniaxial material object for interface rotational spring at node 1. use a zero object to indicate the case that a beam-column element is rigidly framed to the joint.

• mat2 (int) – Uniaxial material object for interface rotational spring at node 2. use a zero object to indicate the case that a beam-column element is rigidly framed to the joint.

• mat3 (int) – Uniaxial material object for interface rotational spring at node 3. use a zero object to indicate the case that a beam-column element is rigidly framed to the joint.

• mat4 (int) – Uniaxial material object for interface rotational spring at node 4. use a zero object to indicate the case that a beam-column element is rigidly framed to the joint.

• mat_c (int) – Uniaxial material object for rotational spring of the central node that describes shear panel behavior

• lrg_dsp (obj) – An integer indicating the flag for considering large deformations: * 0 - for small deformations and constant geometry * 1 - for large deformations and time varying geometry * 2 - for large deformations ,time varying geometry and length correction

• dmg (obj) – Damage model object

• dmg1dmg2dmg3dmg4dmg_c (None, optional) –

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1], [0.5, 0.5]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> o3.element.Joint2D(osi, ele_nodes=ele_nodes, mat1=1, mat2=1, mat3=1, mat4=1, mat_c=1, lrg_dsp='', dmg='', dmg1dmg2dmg3dmg4dmg_c=1)

op_type = 'Joint2D'

Link

class o3seespy.command.element.link.TwoNodeLink(osi, ele_nodes, mats: Optional[list] = None, dirs: Optional[list] = None, p_delta_vals: Optional[list] = None, shear_dist=None, do_rayleigh=False, orient: Optional[list] = None, mass: Optional[float] = None)

Bases: ElementBase

The TwoNodeLink Element Class

This command is used to construct a twoNodeLink element object, which is defined by two nodes. The element can have zero or non-zero length. This element can have 1 to 6 degrees of freedom, where only the transverse and rotational degrees of freedom are coupled as long as the element has non-zero length. In addition, if the element length is larger than zero, the user can optionally specify how the P-Delta moments around the local x- and y-axis are distributed among a moment at node i, a moment at node j, and a shear couple. The sum of these three ratios is always equal to 1. In addition the shear center can be specified as a fraction of the element length from the iNode. The element does not contribute to the Rayleigh damping by default. If the element has non-zero length, the local x-axis is determined from the nodal geometry unless the optional x-axis vector is specified in which case the nodal geometry is ignored and the user-defined orientation is utilized. It is important to recognize that if this element has zero length, it does not consider the geometry as given by the nodal coordinates, but utilizes the user-defined orientation vectors to determine the directions of the springs.

Initial method for TwoNodeLink

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• mats (list, optional) – A list of objects associated with previously-defined uniaxial_material objects

• dirs (list, optional) – A list material directions: * 2d-case: 1 , 2 - translations along local x,y axes; 3 - rotation about local z axis * 3d-case: 1, 2, 3 - translations along local x,y,z axes; 4, 5, 6 - rotations about local x,y,z axes

• p_delta_vals (list, optional) – P-delta moment contribution ratios, size of ratio vector is 2 for 2d-case and 4 for 3d-case (entries: [my_inode, my_jnode, mz_inode, mz_jnode]) my_inode + my_jnode <= 1.0, mz_inode + mz_jnode <= 1.0. remaining p-delta moments are resisted by shear couples.

• shear_dist (None, optional) –

• do_rayleigh (bool) – To include rayleigh damping from the element (optional, default = no rayleigh damping contribution)

• orient (list, optional) –

• mass (float, optional) – Element mass (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> mats = [o3.uniaxial_material.Elastic(osi, 1.0),
>>>         o3.uniaxial_material.Elastic(osi, 1.0)]
>>> p_delta_vals = [1.0, 1.0]
>>> o3.element.TwoNodeLink(osi, ele_nodes=ele_nodes, mats=mats, dir=[1, 1], p_delta_vals=p_delta_vals)

op_type = 'twoNodeLink'

Misc

class o3seespy.command.element.misc.AC3D8(osi, ele_nodes, mat)

Bases: ElementBase

The AC3D8 Element Class

This command is used to construct an eight-node 3D brick acoustic element object based on a trilinear isoparametric formulation.

Initial method for AC3D8

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – 8 end nodes

• mat (obj) – Material object of previously defined nd material

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> o3.element.AC3D8(osi, ele_nodes=ele_nodes, mat=mat)

op_type = 'AC3D8'

class o3seespy.command.element.misc.ASI3D8(osi, ele_nodes1, ele_nodes2)

Bases: ElementBase

The ASI3D8 Element Class

This command is used to construct an eight-node zero-thickness 3D brick acoustic-structure interface element object based on a bilinear isoparametric formulation. The nodes in the acoustic domain share the same coordinates with the nodes in the solid domain.

Initial method for ASI3D8

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes1 (None) –

• ele_nodes2 (None) –

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> o3.element.ASI3D8(osi, ele_nodes1=1, ele_nodes2=1)

op_type = 'ASI3D8'

class o3seespy.command.element.misc.AV3D4(osi, ele_nodes, mat)

Bases: ElementBase

The AV3D4 Element Class

This command is used to construct a four-node 3D acoustic viscous boundary quad element object based on a bilinear isoparametric formulation.

Initial method for AV3D4

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – 4 end nodes

• mat (obj) – Material object of previously defined nd material

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> o3.element.AV3D4(osi, ele_nodes=ele_nodes, mat=mat)

op_type = 'AV3D4'

class o3seespy.command.element.misc.SurfaceLoad(osi, ele_nodes, p)

Bases: ElementBase

The SurfaceLoad Element Class

This command is used to construct a SurfaceLoad element object.

Initial method for SurfaceLoad

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – The four nodes defining the element, input in counterclockwise order (-ndm 3 -ndf 3)

• p (float) – Applied pressure loading normal to the surface, outward is positive, inward is negative

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> o3.element.SurfaceLoad(osi, ele_nodes=ele_nodes, p=1.0)

op_type = 'SurfaceLoad'

class o3seespy.command.element.misc.VS3D4(osi, ele_nodes, big_e, big_g, rho, big_r, alpha_n, alpha_t)

Bases: ElementBase

The VS3D4 Element Class

This command is used to construct a four-node 3D viscous-spring boundary quad element object based on a bilinear isoparametric formulation.

Initial method for VS3D4

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – 4 end nodes

• big_e (float) – Young’s modulus of element material

• big_g (float) – Shear modulus of element material

• rho (float) – Mass density of element material

• big_r (float) – Distance from the scattered wave source to the boundary

• alpha_n (float) – Correction parameter in the normal direction

• alpha_t (float) – Correction parameter in the tangential direction

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> o3.element.VS3D4(osi, ele_nodes=ele_nodes, big_e=1.0, big_g=1.0, rho=1.0, big_r=1.0, alpha_n=1.0, alpha_t=1.0)

op_type = 'VS3D4'

Other UP

class o3seespy.command.element.other_up.SSPbrickUP(osi, ele_nodes, mat, f_bulk, f_den, k1, k2, k3, void, alpha, b1, b2, b3)

Bases: ElementBase

The SSPbrickUP Element Class

This command is used to construct a SSPbrickUP element object.

Initial method for SSPbrickUP

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of eight element nodes in counter-clockwise order

• mat (obj) – Unique integer object associated with previously-defined ndmaterial object

• f_bulk (float) – Bulk modulus of the pore fluid

• f_den (float) – Mass density of the pore fluid

• k1 (float) – Permeability coefficients in global x-, y-, and z-directions, respectively

• k2 (float) – Permeability coefficients in global x-, y-, and z-directions, respectively

• k3 (float) – Permeability coefficients in global x-, y-, and z-directions, respectively

• void (float) – Voids ratio

• alpha (float) – Spatial pressure field stabilization parameter (see discussion below for more information)

• b1 (float) – Constant body forces in global x-, y-, and z-directions, respectively (optional, default = 0.0) - see note 3

• b2 (float) – Constant body forces in global x-, y-, and z-directions, respectively (optional, default = 0.0) - see note 3

• b3 (float) – Constant body forces in global x-, y-, and z-directions, respectively (optional, default = 0.0) - see note 3

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> obj = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> ele_nodes = [o3.node.Node(osi, 0.0, x) for x in range(8)]
>>> o3.element.SSPbrickUP(osi, ele_nodes=ele_nodes, mat=obj, f_bulk=1.0, f_den=1.0, k1=1.0, k2=1.0, k3=1.0, void=0.5, alpha=1.0e-5, b1=1.0, b2=1.0, b3=1.0)

op_type = 'SSPbrickUP'

class o3seespy.command.element.other_up.SSPquadUP(osi, ele_nodes, mat, thick, f_bulk, f_den, k1, k2, void, alpha, b1=0.0, b2=0.0)

Bases: ElementBase

The SSPquadUP Element Class

This command is used to construct a SSPquadUP element object.

Initial method for SSPquadUP

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes in counter-clockwise order

• mat (obj) – Unique integer object associated with previously-defined ndmaterial object

• thick (float) – Thickness of the element in out-of-plane direction

• f_bulk (float) – Bulk modulus of the pore fluid

• f_den (float) – Mass density of the pore fluid

• k1 (float) – Permeability coefficients in global x- and y-directions, respectively

• k2 (float) – Permeability coefficients in global x- and y-directions, respectively

• void (float) – Voids ratio

• alpha (float) – Spatial pressure field stabilization parameter (see discussion below for more information)

• b1 (float, optional) – Constant body forces in global x- and y-directions, respectively (optional, default = 0.0) - see note 3

• b2 (float, optional) – Constant body forces in global x- and y-directions, respectively (optional, default = 0.0) - see note 3

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> obj = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> ele_nodes = [o3.node.Node(osi, 0.0, x) for x in range(4)]
>>> o3.element.SSPquadUP(osi, ele_nodes=ele_nodes, mat=obj, thick=1.0, f_bulk=1.0, f_den=1.0, k1=1.0, k2=1.0, void=1.0, alpha=1.0, b1=0.0, b2=0.0)

op_type = 'SSPquadUP'

PFEM

class o3seespy.command.element.pfem.PFEMElementBubble(osi, ele_nodes, rho, mu, b1, b2, b3, thickness, kappa)

Bases: ElementBase

The PFEMElementBubble Element Class

Create a PFEM Bubble element, which is a fluid element for FSI analysis.

Initial method for PFEMElementBubble

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of three or four element nodes, four are required for 3d

• rho (float) – Fluid density

• mu (float) – Fluid viscosity

• b1 (float) – Body body acceleration in x direction

• b2 (float) – Body body acceleration in y direction

• b3 (float) – Body body acceleration in z direction (required for 3d)

• thickness (float) – Element thickness (required for 2d)

• kappa (float) – Fluid bulk modulus

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> o3.element.PFEMElementBubble(osi, ele_nodes, rho=1.0, mu=1.0, b1=1.0, b2=1.0, b3=1.0, thickness=1.0, kappa=1.0)

op_type = 'PFEMElementBubble'

class o3seespy.command.element.pfem.PFEMElementCompressible(osi, ele_nodes, rho, mu, b1, b2, thickness, kappa)

Bases: ElementBase

The PFEMElementCompressible Element Class

Create a PFEM compressible element, which is a fluid element for FSI analysis.

Initial method for PFEMElementCompressible

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes, last one is middle node

• rho (float) – Fluid density

• mu (float) – Fluid viscosity

• b1 (float) – Body body acceleration in x direction

• b2 (float) – Body body acceleration in y direction

• thickness (float) – Element thickness

• kappa (float) – Fluid bulk modulus

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> o3.element.PFEMElementCompressible(osi, ele_nodes, rho=1.0, mu=1.0, b1=1.0, b2=1.0, thickness=1.0, kappa=1.0)

op_type = 'PFEMElementCompressible'

quadrilateral

class o3seespy.command.element.quadrilateral.BbarQuad(osi, ele_nodes, thick, mat)

Bases: ElementBase

The BbarQuad Element Class

This command is used to construct a four-node quadrilateral element object, which uses a bilinear isoparametric formulation along with a mixed volume/pressure B-bar assumption. This element is for plane strain problems only.

Initial method for BbarQuad

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes in counter-clockwise order

• thick (float) – Element thickness

• mat (obj) – Object of ndmaterial

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2, ndf=2)
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> o3.element.BbarQuad(osi, ele_nodes=ele_nodes, thick=1.0, mat=mat)

op_type = 'bbarQuad'

class o3seespy.command.element.quadrilateral.EnhancedQuad(osi, ele_nodes, thick, otype, mat)

Bases: ElementBase

The EnhancedQuad Element Class

This command is used to construct a four-node quadrilateral element, which uses a bilinear isoparametric formulation with enhanced strain modes.

Initial method for EnhancedQuad

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes in counter-clockwise order

• thick (float) – Element thickness

• otype (str) – String representing material behavior. valid options depend on the ndmaterial object and its available material formulations. the type parameter can be either 'PlaneStrain' or 'PlaneStress'

• mat (obj) – Object of ndmaterial

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2, ndf=2)
>>> obj = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> o3.element.EnhancedQuad(osi, ele_nodes=ele_nodes, thick=1.0, otype='PlaneStress', mat=obj)

op_type = 'enhancedQuad'

class o3seespy.command.element.quadrilateral.MVLEM3DCoR(osi, ele_nodes, m, c, thick: Optional[list] = None, widths: Optional[list] = None, rho: Optional[list] = None, mat_concretes: Optional[list] = None, mat_steels: Optional[list] = None, mat_shear=None)

Bases: ElementBase

The MVLEM3DCoR Element Class

Developed and implemented by: | Kristijan Kolozvari (CSU Fullerton)| Kamiar

Kalbasi (CSU Fullerton)| Kutay Orakcal (Bogazici University)| John Wallace (UCLA)The MVLEM_3D model (Figure 1a) is a three-dimensional four-node element with 24 DOFs for nonlinear analysis of flexure-controlled non-rectangular reinforced concrete walls subjected to multidirectional loading. The model is an extension of the two-dimensional, two-node Multiple-Vertical-Line-Element-Model (`MVLEM

Initial method for MVLEM3DCoR

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes defined in the counter-clockwise direction

• m (int) – Number of element uniaxial fibers

• c (float) – Location of center of rotation from the base (optional; default = 0.4 (recommended))

• thick (list, optional) – A list of m macro-fiber thicknesses

• widths (list, optional) – A list of m macro-fiber widths

• rho (list, optional) – A list of m reinforcing ratios corresponding to macro-fibers; for each fiber:

• mat_concretes (list, optional) – A list of m uniaxial_material objects for concrete

• mat_steels (list, optional) – A list of m uniaxial_material objects for steel

• mat_shear (obj, optional) – Object of uniaxial_material for shear material

op_type = 'MVLEM_3D'

class o3seespy.command.element.quadrilateral.MVLEM3DDensity(osi, ele_nodes, m, dens, thick: Optional[list] = None, widths: Optional[list] = None, rho: Optional[list] = None, mat_concretes: Optional[list] = None, mat_steels: Optional[list] = None, mat_shear=None)

Bases: ElementBase

The MVLEM3DDensity Element Class

Developed and implemented by: | Kristijan Kolozvari (CSU Fullerton)| Kamiar

Kalbasi (CSU Fullerton)| Kutay Orakcal (Bogazici University)| John Wallace (UCLA)The MVLEM_3D model (Figure 1a) is a three-dimensional four-node element with 24 DOFs for nonlinear analysis of flexure-controlled non-rectangular reinforced concrete walls subjected to multidirectional loading. The model is an extension of the two-dimensional, two-node Multiple-Vertical-Line-Element-Model (`MVLEM

Initial method for MVLEM3DDensity

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes defined in the counter-clockwise direction

• m (int) – Number of element uniaxial fibers

• dens (float) – Density (optional; default = 0.0)

• thick (list, optional) – A list of m macro-fiber thicknesses

• widths (list, optional) – A list of m macro-fiber widths

• rho (list, optional) – A list of m reinforcing ratios corresponding to macro-fibers; for each fiber:

• mat_concretes (list, optional) – A list of m uniaxial_material objects for concrete

• mat_steels (list, optional) – A list of m uniaxial_material objects for steel

• mat_shear (obj, optional) – Object of uniaxial_material for shear material

op_type = 'MVLEM_3D'

class o3seespy.command.element.quadrilateral.MVLEM3DPoisson(osi, ele_nodes, m, nu, thick: Optional[list] = None, widths: Optional[list] = None, rho: Optional[list] = None, mat_concretes: Optional[list] = None, mat_steels: Optional[list] = None, mat_shear=None)

Bases: ElementBase

The MVLEM3DPoisson Element Class

Developed and implemented by: | Kristijan Kolozvari (CSU Fullerton)| Kamiar

Kalbasi (CSU Fullerton)| Kutay Orakcal (Bogazici University)| John Wallace (UCLA)The MVLEM_3D model (Figure 1a) is a three-dimensional four-node element with 24 DOFs for nonlinear analysis of flexure-controlled non-rectangular reinforced concrete walls subjected to multidirectional loading. The model is an extension of the two-dimensional, two-node Multiple-Vertical-Line-Element-Model (`MVLEM

Initial method for MVLEM3DPoisson

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes defined in the counter-clockwise direction

• m (int) – Number of element uniaxial fibers

• nu (float) – Poisson ratio for out-of-plane bending (optional; default = 0.25)

• thick (list, optional) – A list of m macro-fiber thicknesses

• widths (list, optional) – A list of m macro-fiber widths

• rho (list, optional) – A list of m reinforcing ratios corresponding to macro-fibers; for each fiber:

• mat_concretes (list, optional) – A list of m uniaxial_material objects for concrete

• mat_steels (list, optional) – A list of m uniaxial_material objects for steel

• mat_shear (obj, optional) – Object of uniaxial_material for shear material

op_type = 'MVLEM_3D'

class o3seespy.command.element.quadrilateral.MVLEM3DThickMod(osi, ele_nodes, m, t_mod, thick: Optional[list] = None, widths: Optional[list] = None, rho: Optional[list] = None, mat_concretes: Optional[list] = None, mat_steels: Optional[list] = None, mat_shear=None)

Bases: ElementBase

The MVLEM3DThickMod Element Class

Developed and implemented by: | Kristijan Kolozvari (CSU Fullerton)| Kamiar

Kalbasi (CSU Fullerton)| Kutay Orakcal (Bogazici University)| John Wallace (UCLA)The MVLEM_3D model (Figure 1a) is a three-dimensional four-node element with 24 DOFs for nonlinear analysis of flexure-controlled non-rectangular reinforced concrete walls subjected to multidirectional loading. The model is an extension of the two-dimensional, two-node Multiple-Vertical-Line-Element-Model (`MVLEM

Initial method for MVLEM3DThickMod

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes defined in the counter-clockwise direction

• m (int) – Number of element uniaxial fibers

• t_mod (float) – Thickness multiplier (optional; default = 0.63 equivalent to 0.25ig for out-of-plane bending)

• thick (list, optional) – A list of m macro-fiber thicknesses

• widths (list, optional) – A list of m macro-fiber widths

• rho (list, optional) – A list of m reinforcing ratios corresponding to macro-fibers; for each fiber:

• mat_concretes (list, optional) – A list of m uniaxial_material objects for concrete

• mat_steels (list, optional) – A list of m uniaxial_material objects for steel

• mat_shear (obj, optional) – Object of uniaxial_material for shear material

op_type = 'MVLEM_3D'

class o3seespy.command.element.quadrilateral.Quad(osi, ele_nodes, thick, otype, mat, pressure=0.0, rho=0.0, b1=0.0, b2=0.0)

Bases: ElementBase

The Quad Element Class

This command is used to construct a FourNodeQuad element object which uses a bilinear isoparametric formulation.

Initial method for Quad

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes in counter-clockwise order

• thick (float) – Element thickness

• otype (str) – String representing material behavior. the type parameter can be either 'planestrain' or 'planestress'

• mat (obj) – Object of ndmaterial

• pressure (float, optional) – Surface pressure (optional, default = 0.0)

• rho (float, optional) – Element mass density (per unit volume) from which a lumped element mass matrix is computed (optional, default=0.0)

• b1 (float, optional) – Constant body forces defined in the isoparametric domain (optional, default=0.0)

• b2 (float, optional) – Constant body forces defined in the isoparametric domain (optional, default=0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2, ndf=2)
>>> obj = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> o3.element.Quad(osi, ele_nodes=ele_nodes, thick=1.0, otype='PlaneStrain', mat=obj, pressure=1.0, rho=1.0, b1=0.0, b2=0.0)

op_type = 'quad'

class o3seespy.command.element.quadrilateral.SFIMVLEM3DCoR(osi, ele_nodes, m, c, thicks: Optional[list] = None, widths: Optional[list] = None, mats: Optional[list] = None)

Bases: ElementBase

The SFIMVLEM3DCoR Element Class

Developed and implemented by: | Kristijan Kolozvari (CSU Fullerton)| Kamiar

Kalbasi (CSU Fullerton)| Kutay Orakcal (Bogazici University)| John Wallace (UCLA)The SFI-MVLEM-3D model (Figure 1a) is a three-dimensional four-node element with 24 DOFs that incorporates axial-flexural-shear interaction and can be used for nonlinear analysis of non-rectangular reinforced concrete walls subjected to multidirectional loading. The SFI-MVLEM-3D model is an extension of the two-dimensional, two-node Shear-Flexure-Interaction Multiple-Vertical-Line-Element-Model (`SFI-MVLEM

Initial method for SFIMVLEM3DCoR

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes defined in the counter-clockwise direction

• m (int) – Number of element uniaxial fibers

• c (float) – Location of center of rotation from the base (optional; default = 0.4 (recommended))

• thicks (list, optional) – A list of m macro-fiber thicknesses

• widths (list, optional) – A list of m macro-fiber widths

• mats (list, optional) – A list of m material objects corresponding to ndmaterial fsam

op_type = 'SFI_MVLEM_3D'

class o3seespy.command.element.quadrilateral.SFIMVLEM3DDensity(osi, ele_nodes, m, dens, thicks: Optional[list] = None, widths: Optional[list] = None, mats: Optional[list] = None)

Bases: ElementBase

The SFIMVLEM3DDensity Element Class

Developed and implemented by: | Kristijan Kolozvari (CSU Fullerton)| Kamiar

Kalbasi (CSU Fullerton)| Kutay Orakcal (Bogazici University)| John Wallace (UCLA)The SFI-MVLEM-3D model (Figure 1a) is a three-dimensional four-node element with 24 DOFs that incorporates axial-flexural-shear interaction and can be used for nonlinear analysis of non-rectangular reinforced concrete walls subjected to multidirectional loading. The SFI-MVLEM-3D model is an extension of the two-dimensional, two-node Shear-Flexure-Interaction Multiple-Vertical-Line-Element-Model (`SFI-MVLEM

Initial method for SFIMVLEM3DDensity

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes defined in the counter-clockwise direction

• m (int) – Number of element uniaxial fibers

• dens (float) – Density (optional; default = 0.0)

• thicks (list, optional) – A list of m macro-fiber thicknesses

• widths (list, optional) – A list of m macro-fiber widths

• mats (list, optional) – A list of m material objects corresponding to ndmaterial fsam

op_type = 'SFI_MVLEM_3D'

class o3seespy.command.element.quadrilateral.SFIMVLEM3DPoisson(osi, ele_nodes, m, nu, thicks: Optional[list] = None, widths: Optional[list] = None, mats: Optional[list] = None)

Bases: ElementBase

The SFIMVLEM3DPoisson Element Class

Developed and implemented by: | Kristijan Kolozvari (CSU Fullerton)| Kamiar

Kalbasi (CSU Fullerton)| Kutay Orakcal (Bogazici University)| John Wallace (UCLA)The SFI-MVLEM-3D model (Figure 1a) is a three-dimensional four-node element with 24 DOFs that incorporates axial-flexural-shear interaction and can be used for nonlinear analysis of non-rectangular reinforced concrete walls subjected to multidirectional loading. The SFI-MVLEM-3D model is an extension of the two-dimensional, two-node Shear-Flexure-Interaction Multiple-Vertical-Line-Element-Model (`SFI-MVLEM

Initial method for SFIMVLEM3DPoisson

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes defined in the counter-clockwise direction

• m (int) – Number of element uniaxial fibers

• nu (float) – Poisson ratio for out-of-plane bending (optional; default = 0.25)

• thicks (list, optional) – A list of m macro-fiber thicknesses

• widths (list, optional) – A list of m macro-fiber widths

• mats (list, optional) – A list of m material objects corresponding to ndmaterial fsam

op_type = 'SFI_MVLEM_3D'

class o3seespy.command.element.quadrilateral.SFIMVLEM3DThickMod(osi, ele_nodes, m, t_mod, thicks: Optional[list] = None, widths: Optional[list] = None, mats: Optional[list] = None)

Bases: ElementBase

The SFIMVLEM3DThickMod Element Class

Developed and implemented by: | Kristijan Kolozvari (CSU Fullerton)| Kamiar

Kalbasi (CSU Fullerton)| Kutay Orakcal (Bogazici University)| John Wallace (UCLA)The SFI-MVLEM-3D model (Figure 1a) is a three-dimensional four-node element with 24 DOFs that incorporates axial-flexural-shear interaction and can be used for nonlinear analysis of non-rectangular reinforced concrete walls subjected to multidirectional loading. The SFI-MVLEM-3D model is an extension of the two-dimensional, two-node Shear-Flexure-Interaction Multiple-Vertical-Line-Element-Model (`SFI-MVLEM

Initial method for SFIMVLEM3DThickMod

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes defined in the counter-clockwise direction

• m (int) – Number of element uniaxial fibers

• t_mod (float) – Thickness multiplier (optional; default = 0.63 equivalent to 0.25ig for out-of-plane bending)

• thicks (list, optional) – A list of m macro-fiber thicknesses

• widths (list, optional) – A list of m macro-fiber widths

• mats (list, optional) – A list of m material objects corresponding to ndmaterial fsam

op_type = 'SFI_MVLEM_3D'

class o3seespy.command.element.quadrilateral.SSPquad(osi, ele_nodes, mat, otype, thick, b1, b2)

Bases: ElementBase

The SSPquad Element Class

This command is used to construct a SSPquad element object.

Initial method for SSPquad

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes in counter-clockwise order

• mat (obj) – Unique integer object associated with previously-defined ndmaterial object

• otype (str) – String to relay material behavior to the element, can be either 'planestrain' or 'planestress'

• thick (float) – Thickness of the element in out-of-plane direction

• b1 (float) – Constant body forces in global x- and y-directions, respectively (optional, default = 0.0)

• b2 (float) – Constant body forces in global x- and y-directions, respectively (optional, default = 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> obj = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> o3.element.SSPquad(osi, ele_nodes=ele_nodes, mat=obj, otype='PlaneStrain', thick=1.0, b1=0.0, b2=0.0)

op_type = 'SSPquad'

class o3seespy.command.element.quadrilateral.ShellDKGQ(osi, ele_nodes, sec)

Bases: ElementBase

The ShellDKGQ Element Class

This command is used to construct a ShellDKGQ element object, which is a quadrilateral shell element based on the theory of generalized conforming element.

Initial method for ShellDKGQ

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes in counter-clockwise order

• sec (obj) – Object associated with previously-defined sectionforcedeformation object. currently can be a 'platefibersection', a 'elasticmembraneplatesection' and a 'layeredshell' section

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> sec = o3.section.Elastic2D(osi, 10.0, 1.0, 1.0)
>>> o3.element.ShellDKGQ(osi, ele_nodes=ele_nodes, sec=sec)

op_type = 'ShellDKGQ'

class o3seespy.command.element.quadrilateral.ShellDKGT(osi, ele_nodes, sec)

Bases: ElementBase

The ShellDKGT Element Class

This command is used to construct a ShellDKGT element object, which is a triangular shell element based on the theory of generalized conforming element.

Initial method for ShellDKGT

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of three element nodes in clockwise or counter-clockwise order

• sec (obj) – Object associated with previously-defined sectionforcedeformation object. currently can be a 'platefibersection', a 'elasticmembraneplatesection' and a 'layeredshell' section

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> sec = o3.section.Elastic2D(osi, 10.0, 1.0, 1.0)
>>> o3.element.ShellDKGT(osi, ele_nodes=ele_nodes, sec=sec)

op_type = 'ShellDKGT'

class o3seespy.command.element.quadrilateral.ShellMITC4(osi, ele_nodes, sec)

Bases: ElementBase

The ShellMITC4 Element Class

This command is used to construct a ShellMITC4 element object, which uses a bilinear isoparametric formulation in combination with a modified shear interpolation to improve thin-plate bending performance.

Initial method for ShellMITC4

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes in counter-clockwise order

• sec (obj) – Object associated with previously-defined sectionforcedeformation object. currently must be either a 'platefibersection', or 'elasticmembraneplatesection'

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> sec = o3.section.Elastic2D(osi, 10.0, 1.0, 1.0)
>>> o3.element.ShellMITC4(osi, ele_nodes=ele_nodes, sec=sec)

op_type = 'ShellMITC4'

class o3seespy.command.element.quadrilateral.ShellNL(osi, ele_nodes, sec)

Bases: ElementBase

The ShellNL Element Class

Initial method for ShellNL

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of nine element nodes, input is the typical, firstly four corner nodes counter-clockwise, then mid-side nodes counter-clockwise and finally the central node

• sec (obj) – Object associated with previously-defined sectionforcedeformation object. currently can be a 'platefibersection', a 'elasticmembraneplatesection' and a 'layeredshell' section

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1], [0.5, 0], [1, 0.5], [0.5, 1], [0, 0.5], [0.5, 0.5]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> sec = o3.section.Elastic2D(osi, 10.0, 1.0, 1.0)
>>> o3.element.ShellNL(osi, ele_nodes=ele_nodes, sec=sec)

op_type = 'ShellNL'

class o3seespy.command.element.quadrilateral.ShellNLDKGQ(osi, ele_nodes, sec)

Bases: ElementBase

The ShellNLDKGQ Element Class

This command is used to construct a ShellNLDKGQ element object accounting for the geometric nonlinearity of large deformation using the updated Lagrangian formula, which is developed based on the ShellDKGQ element.

Initial method for ShellNLDKGQ

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes in counter-clockwise order

• sec (obj) – Object associated with previously-defined sectionforcedeformation object. currently can be a 'platefibersection', a 'elasticmembraneplatesection' and a 'layeredshell' section

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> sec = o3.section.Elastic2D(osi, 10.0, 1.0, 1.0)
>>> o3.element.ShellNLDKGQ(osi, ele_nodes=ele_nodes, sec=sec)

op_type = 'ShellNLDKGQ'

class o3seespy.command.element.quadrilateral.ShellNLDKGT(osi, ele_nodes, sec)

Bases: ElementBase

The ShellNLDKGT Element Class

This command is used to construct a ShellNLDKGT element object accounting for the geometric nonlinearity of large deformation using the updated Lagrangian formula, which is developed based on the ShellDKGT element.

Initial method for ShellNLDKGT

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of three element nodes in clockwise or counter-clockwise order around the element

• sec (obj) – Object associated with previously-defined sectionforcedeformation object. currently can be a 'platefibersection', a 'elasticmembraneplatesection' and a 'layeredshell' section

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> sec = o3.section.Elastic2D(osi, 10.0, 1.0, 1.0)
>>> o3.element.ShellNLDKGT(osi, ele_nodes=ele_nodes, sec=sec)

op_type = 'ShellNLDKGT'

Soil-foundation

class o3seespy.command.element.soil_foundation.BeamOnNonlinearWinklerFoundation(top_nodes, bot_nodes, sf_eles, fd_eles, sf_mats=None, sf_horz_eles=None, sf_horz_mats=None)

Bases: object

o3seespy.command.element.soil_foundation.gen_shallow_foundation_bnwf(osi, bottom_node, top_node, sf_mats, pos, fd_area, fd_e_mod, fd_iz, r_flag: Optional[float] = None, orient: Optional[list] = None, sf_horz_mats=None, sf_frn=None, offset=0.0)

Generates nodes and elements for a shallow foundation beam on nonlinear foundation

Alpha Status - Subject to changes and testing

Note: Only supports 2D

Parameters

• osi –

• bottom_node –

• top_node –

• sf_mats –

• pos –

• fd_area –

• fd_e_mod –

• fd_iz –

• r_flag –

• orient –

Tetrahedron

class o3seespy.command.element.tetrahedron.FourNodeTetrahedron(osi, ele_nodes, mat, b1, b2, b3)

Bases: ElementBase

The FourNodeTetrahedron Element Class

This command is used to construct a standard four-node tetrahedron element objec with one-point Gauss integration.

Initial method for FourNodeTetrahedron

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes

• mat (obj) – Object of ndmaterial

• b1 (float) – Body forces in global x,y,z directions

• b2 (float) – Body forces in global x,y,z directions

• b3 (float) – Body forces in global x,y,z directions

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> o3.element.FourNodeTetrahedron(osi, ele_nodes=ele_nodes, mat=mat, b1=1.0, b2=1.0, b3=1.0)

op_type = 'FourNodeTetrahedron'

Triangular

class o3seespy.command.element.triangular.Tri31(osi, ele_nodes, thick, otype, mat, pressure, rho, b1, b2)

Bases: ElementBase

The Tri31 Element Class

This command is used to construct a constant strain triangular element (Tri31) which uses three nodes and one integration points.

Initial method for Tri31

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of three element nodes in counter-clockwise order

• thick (float) – Element thickness

• otype (str) – String representing material behavior. the type parameter can be either 'planestrain' or 'planestress'

• mat (obj) – Object of ndmaterial

• pressure (float) – Surface pressure (optional, default = 0.0)

• rho (float) – Element mass density (per unit volume) from which a lumped element mass matrix is computed (optional, default=0.0)

• b1 (float) – Constant body forces defined in the domain (optional, default=0.0)

• b2 (float) – Constant body forces defined in the domain (optional, default=0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(3)]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> o3.element.Tri31(osi, ele_nodes=ele_nodes, thick=1.0, otype=o3.cc.PLANE_STRAIN, mat=mat, pressure=1.0, rho=1.0, b1=1.0, b2=1.0)

op_type = 'Tri31'

Truss

class o3seespy.command.element.truss.CorotTruss(osi, ele_nodes, big_a, mat, rho: Optional[float] = None, c_flag: Optional[float] = None, r_flag: Optional[float] = None)

Bases: ElementBase

The CorotTruss Element Class

This command is used to construct a corotational truss element object. There are two ways to construct a corotational truss element object:

One way is to specify an area and a UniaxialMaterial identifier:

Initial method for CorotTruss

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• big_a (float) – Cross-sectional area of element

• mat (obj) – Object associated with previously-defined uniaxial_material

• rho (float, optional) – Mass per unit length, optional, default = 0.0

• c_flag (float, optional) – Consistent mass flag, optional, default = 0 * cflag = 0 lumped mass matrix (default) * cflag = 1 consistent mass matrix

• r_flag (float, optional) – Rayleigh damping flag, optional, default = 0 * rflag = 0 no rayleigh damping (default) * rflag = 1 include rayleigh damping

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat = o3.uniaxial_material.Elastic(osi, 1.0)
>>> o3.element.CorotTruss(osi, ele_nodes=ele_nodes, big_a=1.0, mat=mat, rho=1.0, c_flag=1.0, r_flag=1.0)

op_type = 'corotTruss'

class o3seespy.command.element.truss.Truss(osi, ele_nodes, big_a, mat, rho: Optional[float] = None, c_flag: Optional[float] = None, r_flag: Optional[float] = None)

Bases: ElementBase

The Truss Element Class

This command is used to construct a truss element object. There are two ways to construct a truss element object:

One way is to specify an area and a UniaxialMaterial identifier:

Initial method for Truss

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• big_a (float) – Cross-sectional area of element

• mat (obj) – Object associated with previously-defined uniaxial_material

• rho (float, optional) – Mass per unit length, optional, default = 0.0

• c_flag (float, optional) – Consistent mass flag, optional, default = 0 * cflag = 0 lumped mass matrix (default) * cflag = 1 consistent mass matrix

• r_flag (float, optional) – Rayleigh damping flag, optional, default = 0 * rflag = 0 no rayleigh damping (default) * rflag = 1 include rayleigh damping

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat = o3.uniaxial_material.Elastic(osi, 1.0)
>>> o3.element.Truss(osi, ele_nodes=ele_nodes, big_a=1.0, mat=mat, rho=1.0, c_flag=1.0, r_flag=1.0)

op_type = 'Truss'

UC San Diego UP

class o3seespy.command.element.uc_san_diego_up.BbarBrickUP(osi, ele_nodes, mat, bulk, fmass, perm_x, perm_y, perm_z, b_x=0, b_y=0, b_z=0)

Bases: ElementBase

The BbarBrickUP Element Class

bbarBrickUP is a 8-node mixed volume/pressure element, which uses a tri-linear isoparametric formulation.Each node has 4 degrees-of-freedom (DOF): DOFs 1 to 3 for solid displacement (u) and DOF 4 for fluid pressure (p). This element is implemented for simulating dynamic response of solid-fluid fully coupled material, based on Biot’s theory of porous medium.

Initial method for BbarBrickUP

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of eight element nodes

• mat (obj) – Object of an ndmaterial object (previously defined) of which the element is composed

• bulk (float) – Combined undrained bulk modulus bc relating changes in pore pressure and volumetric strain, may be approximated by: where is the bulk modulus of fluid phase ( kpa (or psi) for water), and n the initial porosity.

• fmass (float) – Fluid mass density

• perm_x (float) – Permeability coefficients in x, y, and z directions respectively.

• perm_y (float) – Permeability coefficients in x, y, and z directions respectively.

• perm_z (float) – Permeability coefficients in x, y, and z directions respectively.

• b_x (float, optional) – Optional gravity acceleration components in x, y, and z directions directions respectively (defaults are 0.0)

• b_y (float, optional) – Optional gravity acceleration components in x, y, and z directions directions respectively (defaults are 0.0)

• b_z (float, optional) – Optional gravity acceleration components in x, y, and z directions directions respectively (defaults are 0.0)

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=3)
>>> coords = [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> o3.element.BbarBrickUP(osi, ele_nodes=ele_nodes, mat=mat, bulk=1.0, fmass=1.0, perm_x=1.0, perm_y=1.0, perm_z=1.0, b_x=0, b_y=0, b_z=0)

op_type = 'bbarBrickUP'

class o3seespy.command.element.uc_san_diego_up.BbarQuadUP(osi, ele_nodes, thick, mat, bulk, fmass, h_perm, v_perm, b1=0, b2=0, t=0)

Bases: ElementBase

The BbarQuadUP Element Class

bbarQuadUP is a four-node plane-strain mixed volume/pressure element, which uses a tri-linear isoparametric formulation. This element is implemented for simulating dynamic response of solid-fluid fully coupled material, based on Biot’s theory of porous medium. Each element node has 3 degrees-of-freedom (DOF): DOF 1 and 2 for solid displacement (u) and DOF 3 for fluid pressure (p).

Initial method for BbarQuadUP

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes in counter-clockwise order

• thick (float) – Element thickness

• mat (obj) – Object of an ndmaterial object (previously defined) of which the element is composed

• bulk (float) – Combined undrained bulk modulus bc relating changes in pore pressure and volumetric strain, may be approximated by: where is the bulk modulus of fluid phase ( kpa (or psi) for water), and n the initial porosity.

• fmass (float) – Fluid mass density

• h_perm (float) – Permeability coefficient in horizontal and vertical directions respectively.

• v_perm (float) – Permeability coefficient in horizontal and vertical directions respectively.

• b1 (float, optional) – Optional gravity acceleration components in horizontal and vertical directions respectively (defaults are 0.0)

• b2 (float, optional) – Optional gravity acceleration components in horizontal and vertical directions respectively (defaults are 0.0)

• t (float, optional) – Optional uniform element normal traction, positive in tension (default is 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> o3.element.BbarQuadUP(osi, ele_nodes=ele_nodes, thick=1.0, mat=mat, bulk=1.0, fmass=1.0, h_perm=1.0, v_perm=1.0, b1=0, b2=0, t=0)

op_type = 'bbarQuadUP'

class o3seespy.command.element.uc_san_diego_up.BrickUP(osi, ele_nodes, mat, bulk, fmass, perm_x, perm_y, perm_z, b_x=0, b_y=0, b_z=0)

Bases: ElementBase

The BrickUP Element Class

BrickUP is an 8-node hexahedral linear isoparametric element. Each node has 4 degrees-of-freedom (DOF): DOFs 1 to 3 for solid displacement (u) and DOF 4 for fluid pressure (p). This element is implemented for simulating dynamic response of solid-fluid fully coupled material, based on Biot’s theory of porous medium.

Initial method for BrickUP

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of eight element nodes

• mat (obj) – Object of an ndmaterial object (previously defined) of which the element is composed

• bulk (float) – Combined undrained bulk modulus bc relating changes in pore pressure and volumetric strain, may be approximated by: where is the bulk modulus of fluid phase ( kpa (or psi) for water), and n the initial porosity.

• fmass (float) – Fluid mass density

• perm_x (float) – Permeability coefficients in x, y, and z directions respectively.

• perm_y (float) – Permeability coefficients in x, y, and z directions respectively.

• perm_z (float) – Permeability coefficients in x, y, and z directions respectively.

• b_x (float, optional) – Optional gravity acceleration components in x, y, and z directions directions respectively (defaults are 0.0)

• b_y (float, optional) – Optional gravity acceleration components in x, y, and z directions directions respectively (defaults are 0.0)

• b_z (float, optional) – Optional gravity acceleration components in x, y, and z directions directions respectively (defaults are 0.0)

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=3, ndf=6)
>>> coords = [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> o3.element.BrickUP(osi, ele_nodes=ele_nodes, mat=mat, bulk=1.0, fmass=1.0, perm_x=1.0, perm_y=1.0, perm_z=1.0, b_x=0, b_y=0, b_z=0)

op_type = 'brickUP'

class o3seespy.command.element.uc_san_diego_up.N208BrickUP(osi, ele_nodes, mat, bulk, fmass, perm_x, perm_y, perm_z, b_x=0, b_y=0, b_z=0)

Bases: ElementBase

The N208BrickUP Element Class

Twenty_Eight_Node_BrickUP is a 20-node hexahedral isoparametric element.The eight corner nodes have 4 degrees-of-freedom (DOF) each: DOFs 1 to 3 for solid displacement (u) and DOF 4 for fluid pressure (p). The other nodes have 3 DOFs each for solid displacement. This element is implemented for simulating dynamic response of solid-fluid fully coupled material, based on Biot’s theory of porous medium.

Initial method for N208BrickUP

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of twenty element nodes

• mat (obj) – Object of an ndmaterial object (previously defined) of which the element is composed

• bulk (float) – Combined undrained bulk modulus bc relating changes in pore pressure and volumetric strain, may be approximated by: where is the bulk modulus of fluid phase ( kpa (or psi) for water), and n the initial porosity.

• fmass (float) – Fluid mass density

• perm_x (float) – Permeability coefficients in x, y, and z directions respectively.

• perm_y (float) – Permeability coefficients in x, y, and z directions respectively.

• perm_z (float) – Permeability coefficients in x, y, and z directions respectively.

• b_x (float, optional) – Optional gravity acceleration components in x, y, and z directions directions respectively (defaults are 0.0)

• b_y (float, optional) – Optional gravity acceleration components in x, y, and z directions directions respectively (defaults are 0.0)

• b_z (float, optional) – Optional gravity acceleration components in x, y, and z directions directions respectively (defaults are 0.0)

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=3)
>>> coords = [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> o3.element.N208BrickUP(osi, ele_nodes=ele_nodes, mat=mat, bulk=1.0, fmass=1.0, perm_x=1.0, perm_y=1.0, perm_z=1.0, b_x=0, b_y=0, b_z=0)

op_type = '20_8_BrickUP'

class o3seespy.command.element.uc_san_diego_up.N94QuadUP(osi, ele_nodes, thick, mat, bulk, fmass, h_perm, v_perm, b1=0, b2=0)

Bases: ElementBase

The N94QuadUP Element Class

Nine_Four_Node_QuadUP is a 9-node quadrilateral plane-strain element. The four corner nodes have 3 degrees-of-freedom (DOF) each: DOF 1 and 2 for solid displacement (u) and DOF 3 for fluid pressure (p). The other five nodes have 2 DOFs each for solid displacement. This element is implemented for simulating dynamic response of solid-fluid fully coupled material, based on Biot’s theory of porous medium.

Initial method for N94QuadUP

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of nine element nodes

• thick (float) – Element thickness

• mat (obj) – Object of an ndmaterial object (previously defined) of which the element is composed

• bulk (float) – Combined undrained bulk modulus bc relating changes in pore pressure and volumetric strain, may be approximated by: where is the bulk modulus of fluid phase ( kpa (or psi) for water), and n the initial porosity.

• fmass (float) – Fluid mass density

• h_perm (float) – Permeability coefficient in horizontal and vertical directions respectively.

• v_perm (float) – Permeability coefficient in horizontal and vertical directions respectively.

• b1 (float, optional) – Optional gravity acceleration components in horizontal and vertical directions respectively (defaults are 0.0)

• b2 (float, optional) – Optional gravity acceleration components in horizontal and vertical directions respectively (defaults are 0.0)

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1], [0.5, 0.5, 0.5]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> o3.element.N94QuadUP(osi, ele_nodes=ele_nodes, thick=1.0, mat=mat, bulk=1.0, fmass=1.0, h_perm=1.0, v_perm=1.0, b1=0, b2=0)

op_type = '9_4_QuadUP'

class o3seespy.command.element.uc_san_diego_up.QuadUP(osi, ele_nodes, thick, mat, bulk, fmass, h_perm, v_perm, b1=0, b2=0, t=0)

Bases: ElementBase

The QuadUP Element Class

FourNodeQuadUP is a four-node plane-strain element using bilinear isoparametric formulation. This element is implemented for simulating dynamic response of solid-fluid fully coupled material, based on Biot’s theory of porous medium. Each element node has 3 degrees-of-freedom (DOF): DOF 1 and 2 for solid displacement (u) and DOF 3 for fluid pressure (p).

Initial method for QuadUP

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of four element nodes in counter-clockwise order

• thick (float) – Element thickness

• mat (obj) – Object of an ndmaterial object (previously defined) of which the element is composed

• bulk (float) – Combined undrained bulk modulus bc relating changes in pore pressure and volumetric strain, may be approximated by: where is the bulk modulus of fluid phase ( kpa (or psi) for water), and n the initial porosity.

• fmass (float) – Fluid mass density

• h_perm (float) – Permeability coefficient in horizontal and vertical directions respectively.

• v_perm (float) – Permeability coefficient in horizontal and vertical directions respectively.

• b1 (float, optional) – Optional gravity acceleration components in horizontal and vertical directions respectively (defaults are 0.0)

• b2 (float, optional) – Optional gravity acceleration components in horizontal and vertical directions respectively (defaults are 0.0)

• t (float, optional) – Optional uniform element normal traction, positive in tension (default is 0.0)

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1, 0.45)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(len(coords))]
>>> o3.element.QuadUP(osi, ele_nodes=ele_nodes, thick=1.0, mat=mat, bulk=1.0, fmass=1.0, h_perm=1.0, v_perm=1.0, b1=0, b2=0, t=0)

op_type = 'quadUP'

Zero length

class o3seespy.command.element.zero_length.CoupledZeroLength(osi, ele_nodes, dirn1, dirn2, mat, r_flag=1)

Bases: ElementBase

The CoupledZeroLength Element Class

Initial method for CoupledZeroLength

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• dirn1 (int) – The two directions, 1 through ndof.

• dirn2 (int) – The two directions, 1 through ndof.

• mat (obj) – Objects associated with previously-defined uniaxial_material

• r_flag (float, optional) – Optional, default = 0 * rflag = 0 no rayleigh damping (default) * rflag = 1 include rayleigh damping

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [0, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> mat = o3.uniaxial_material.Elastic(osi, 1.0)
>>> o3.element.CoupledZeroLength(osi, ele_nodes=ele_nodes, dirn1=1, dirn2=1, mat=mat, r_flag=1)

op_type = 'CoupledZeroLength'

class o3seespy.command.element.zero_length.ZeroLength(osi, ele_nodes, mats: Optional[list] = None, dirs: Optional[list] = None, r_flag: Optional[float] = None, orient: Optional[list] = None)

Bases: ElementBase

The ZeroLength Element Class

This command is used to construct a zeroLength element object, which is defined by two nodes at the same location. The nodes are connected by multiple UniaxialMaterial objects to represent the force-deformation relationship for the element.

Initial method for ZeroLength

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• mats (list, optional) – A list of objects associated with previously-defined uniaxial_materials

• dirs (list, optional) – A list of material directions: * 1,2,3 - translation along local x,y,z axes, respectively; * 4,5,6 - rotation about local x,y,z axes, respectively

• r_flag (float, optional) – Optional, default = 0 * rflag = 0 no rayleigh damping (default)

• orient (list, optional) – [x1, x2, x3, y1, y2, y3] to define local x and y directions. Note that compression is loading in the axis direction (when loading the first node). i.e. orient = [-1, 0, 0, 0, -1, 0] results in compression in the left and downward dirs.

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [0, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> bilinear_mat = o3.uniaxial_material.Steel01(osi, fy=300., e0=200.0e3, b=0.01)
>>> o3.element.ZeroLength(osi, ele_nodes, mats=[bilinear_mat], dirs=[o3.cc.DOF2D_X], r_flag=1)

op_type = 'zeroLength'

class o3seespy.command.element.zero_length.ZeroLengthContact2Dnormal(osi, ele_nodes, kn, kt, mu, nx, ny)

Bases: ElementBase

The ZeroLengthContact2Dnormal Element Class

This command is used to construct a zeroLengthContact2D element, which is Node-to-node frictional contact element used in two dimensional analysis and three dimensional analysis:

Initial method for ZeroLengthContact2Dnormal

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of a constrained and a retained nodes

• kn (float) – Penalty in normal direction

• kt (float) – Penalty in tangential direction

• mu (float) – Friction coefficient

• nx (None) –

• ny (None) –

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [0, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> o3.element.ZeroLengthContact2Dnormal(osi, ele_nodes=ele_nodes, kn=1.0, kt=1.0, mu=1.0, nx=1, ny=0)

op_type = 'zeroLengthContact2D'

class o3seespy.command.element.zero_length.ZeroLengthContact3D(osi, ele_nodes, kn, kt, mu, c, direction)

Bases: ElementBase

The ZeroLengthContact3D Element Class

This command is used to construct a zeroLengthContact3D element, which is Node-to-node frictional contact element used in two dimensional analysis and three dimensional analysis:

Initial method for ZeroLengthContact3D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of a constrained and a retained nodes

• kn (float) – Penalty in normal direction

• kt (float) – Penalty in tangential direction

• mu (float) – Friction coefficient

• c (float) – Cohesion (not available in 2d)

• dir (int) – Direction flag of the contact plane (3d), it can be: * 1 out normal of the master plane pointing to +x direction * 2 out normal of the master plane pointing to +y direction * 3 out normal of the master plane pointing to +z direction

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> o3.element.ZeroLengthContact3D(osi, ele_nodes=ele_nodes, kn=1.0, kt=1.0, mu=1.0, c=1.0, dir=1)

op_type = 'zeroLengthContact3D'

class o3seespy.command.element.zero_length.ZeroLengthContactNTS2D(osi, kn, kt, phi, s_nd_num: Optional[int] = None, m_nd_num: Optional[int] = None, nodes: Optional[list] = None)

Bases: ElementBase

The ZeroLengthContactNTS2D Element Class

Initial method for ZeroLengthContactNTS2D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• kn (float) – Penalty in normal direction

• kt (float) – Penalty in tangential direction

• phi (float) – Friction angle in degrees

• s_nd_num (int, optional) – Number of slave nodes

• m_nd_num (int, optional) – Number of master nodes

• nodes (list, optional) – Slave and master node objects respectively

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [0, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> o3.element.ZeroLengthContactNTS2D(osi, s_nd_num=1, m_nd_num=1, nodes=ele_nodes, kn=1.0, kt=1.0, phi=1.0)

op_type = 'zeroLengthContactNTS2D'

class o3seespy.command.element.zero_length.ZeroLengthImpact3D(osi, ele_nodes, direction, init_gap, friction_ratio, kt, kn, kn2, delta_y, cohesion)

Bases: ElementBase

The ZeroLengthImpact3D Element Class

This command constructs a node-to-node zero-length contact element in 3D space to simulate the impact/pounding and friction phenomena.

Initial method for ZeroLengthImpact3D

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of a constrained and a retained nodes * 1 if out-normal vector of master plane points to +x direction * 2 if out-normal vector of master plane points to +y direction * 3 if out-normal vector of master plane points to +z direction

• direction (None) –

• init_gap (float) – Initial gap between master plane and slave plane

• friction_ratio (float) – Friction ratio in two tangential directions (parallel to master and slave planes)

• kt (float) – Penalty in two tangential directions

• kn (float) – Penalty in normal direction (normal to master and slave planes)

• kn2 (float) – Penalty in normal direction after yielding based on hertz impact model

• delta_y (float) – Yield deformation based on hertz impact model

• cohesion (float) – Cohesion, if no cohesion, it is zero

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [1, 0], [1, 1], [0, 1]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(4)]
>>> o3.element.ZeroLengthImpact3D(osi, ele_nodes=ele_nodes, direction=1, init_gap=1.0, friction_ratio=1.0, kt=1.0, kn=1.0, kn2=1.0, delta_y=1.0, cohesion=1.0)

op_type = 'zeroLengthImpact3D'

class o3seespy.command.element.zero_length.ZeroLengthInterface2Ddof(osi, sdof, mdof, kn, kt, phi, s_nd_num: Optional[int] = None, m_nd_num: Optional[int] = None, nodes: Optional[list] = None)

Bases: ElementBase

The ZeroLengthInterface2Ddof Element Class

Initial method for ZeroLengthInterface2Ddof

Parameters

• osi (o3seespy.OpenSeesInstance) –

• sdof (int) – Slave and master degree of freedom

• mdof (int) – Slave and master degree of freedom

• kn (float) – Penalty in normal direction

• kt (float) – Penalty in tangential direction

• phi (float) – Friction angle in degrees

• s_nd_num (int, optional) – Number of slave nodes

• m_nd_num (int, optional) – Number of master nodes

• nodes (list, optional) – Slave and master node objects respectively

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> nodes = [1, 1]
>>> o3.element.ZeroLengthInterface2Ddof(osi, s_nd_num=1, m_nd_num=1, sdof=1, mdof=1, nodes=nodes, kn=1.0, kt=1.0, phi=1.0)

op_type = 'zeroLengthInterface2D'

class o3seespy.command.element.zero_length.ZeroLengthND(osi, ele_nodes, mat, uni, orient: Optional[list] = None)

Bases: ElementBase

The ZeroLengthND Element Class

This command is used to construct a zeroLengthND element object, which is defined by two nodes at the same location. The nodes are connected by a single NDMaterial object to represent the force-deformation relationship for the element.

Initial method for ZeroLengthND

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• mat (obj) – Object associated with previously-defined ndmaterial object

• uni (obj) – Object associated with previously-defined uniaxial_material object which may be used to represent uncoupled behavior orthogonal to the plane of the ndmaterial response. see notes 2 and 3.

• orient (list, optional) – Either [x1, x2, x3] to define local x direction or [x1, x2, x3, y1, y2, y3] to define local x and y direction

Examples

>>> import o3seespy as o3
>>> # Example is currently not working
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [0, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> mat = o3.nd_material.ElasticIsotropic(osi, 1.0, 0.3)
>>> uni = o3.uniaxial_material.Elastic(osi, 1.0)
>>> o3.element.ZeroLengthND(osi, ele_nodes=ele_nodes, mat=mat, uni=uni, orient=[1, 2, 3, 4, 5, 6])

op_type = 'zeroLengthND'

class o3seespy.command.element.zero_length.ZeroLengthSection(osi, ele_nodes, sec, r_flag: Optional[float] = None, orient: Optional[list] = None)

Bases: ElementBase

The ZeroLengthSection Element Class

This command is used to construct a zero length element object, which is defined by two nodes at the same location. The nodes are connected by a single section object to represent the force-deformation relationship for the element.

Initial method for ZeroLengthSection

Parameters

• osi (o3seespy.OpenSeesInstance) –

• ele_nodes (list) – A list of two element nodes

• sec (obj) – Object associated with previously-defined section object

• r_flag (float, optional) – Optional, default = 0 * rflag = 0 no rayleigh damping (default) * rflag = 1 include rayleigh damping

• orient (list, optional) –

Examples

>>> import o3seespy as o3
>>> osi = o3.OpenSeesInstance(ndm=2)
>>> coords = [[0, 0], [0, 0]]
>>> ele_nodes = [o3.node.Node(osi, *coords[x]) for x in range(2)]
>>> sec = o3.section.Elastic2D(osi, 10.0, 1.0, 1.0)
>>> o3.element.ZeroLengthSection(osi, ele_nodes=ele_nodes, sec=sec, r_flag=1.0, orient=[1])

op_type = 'zeroLengthSection'