From 2753ba34e2570410bc655b6a28df00ad70a950d7 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:03:10 -0800 Subject: [PATCH 01/35] docs(consolidate): add Truss element from OpenSeesPyDoc and wiki Co-authored-by: Cursor --- source/user/manual/model/elements/Truss.rst | 58 +++++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 source/user/manual/model/elements/Truss.rst diff --git a/source/user/manual/model/elements/Truss.rst b/source/user/manual/model/elements/Truss.rst new file mode 100644 index 00000000..ea32f466 --- /dev/null +++ b/source/user/manual/model/elements/Truss.rst @@ -0,0 +1,58 @@ +.. _truss: + +Truss Element +^^^^^^^^^^^^^ + +This command is used to construct a truss element object. There are two ways to construct a truss element: by specifying an area and a UniaxialMaterial, or by specifying a Section. + +.. function:: element truss $eleTag $iNode $jNode $A $matTag <-rho $rho> <-cMass> <-doRayleigh $rFlag> + + Construct a truss element with cross-sectional area and a UniaxialMaterial. + +.. function:: element trussSection $eleTag $iNode $jNode $secTag <-rho $rho> <-cMass> <-doRayleigh $rFlag> + + Construct a truss element with a Section identifier. + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $eleTag, |integer|, unique element object tag + $iNode $jNode, |integer|, end node tags + $A, |float|, cross-sectional area of element + $matTag, |integer|, tag associated with previously-defined UniaxialMaterial + $secTag, |integer|, tag associated with previously-defined Section + $rho, |float|, mass per unit length (optional, default = 0.0) + -cMass, |string|, use consistent mass matrix (optional; default is lumped) + $rFlag, |integer|, "| Rayleigh damping flag (optional, default = 0) + | 0 = NO RAYLEIGH DAMPING (default) + | 1 = include Rayleigh damping" + +.. note:: + + #. The truss element does not include geometric nonlinearities, even when used with beam-columns utilizing P-Delta or Corotational transformations. + #. When constructed with a UniaxialMaterial object, the truss element considers strain-rate effects and is suitable for use as a damping element. + #. The valid queries to a truss element when creating an ElementRecorder object are 'axialForce,' 'forces,' 'localForce,' 'deformations,' 'material matArg1 matArg2...' and 'section sectArg1 sectArg2...' + #. For backward compatibility, ``element truss $eleTag $iNode $jNode $secTag`` (four args after nodes) still creates a TrussSection element. + +.. seealso:: + + `Notes (OpenSees wiki) `_ + +.. admonition:: Example + + The following example constructs a truss element with tag **1** between nodes **2** and **4**, area **5.5**, and material tag **9** (from the OpenSees wiki). + + 1. **Tcl Code** + + .. code-block:: tcl + + element truss 1 2 4 5.5 9 + + 2. **Python Code** + + .. code-block:: python + + ops.element('Truss', 1, 2, 4, 5.5, 9) + +Code developed by: |fmk| From 6956d4fbacc0aa6a800eeaf910ed35ce2caa89dd Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:03:10 -0800 Subject: [PATCH 02/35] docs(consolidate): add CoupledZeroLength element from OpenSeesPyDoc and wiki Co-authored-by: Cursor --- .../model/elements/CoupledZeroLength.rst | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 source/user/manual/model/elements/CoupledZeroLength.rst diff --git a/source/user/manual/model/elements/CoupledZeroLength.rst b/source/user/manual/model/elements/CoupledZeroLength.rst new file mode 100644 index 00000000..316816d1 --- /dev/null +++ b/source/user/manual/model/elements/CoupledZeroLength.rst @@ -0,0 +1,62 @@ +.. _coupledZeroLength: + +CoupledZeroLength Element +^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a CoupledZeroLength element object. The element is defined by two nodes at the same location and couples two degrees of freedom (dirn1 and dirn2) through a single UniaxialMaterial. Unlike a ZeroLength element, which provides a rectangular force interaction surface in a 2D plane, this element provides a circular force interaction surface in the plane of the two directions. + +.. function:: element coupledZeroLength $eleTag $iNode $jNode $dirn1 $dirn2 $matTag <-doRayleigh $rFlag> + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $eleTag, |integer|, unique element object tag + $iNode $jNode, |integer|, end node tags + $dirn1 $dirn2, |integer|, the two coupled directions (1 through ndf) + $matTag, |integer|, tag associated with previously-defined UniaxialMaterial + $rFlag, |integer|, "| optional, default = 0 + | 0 = NO RAYLEIGH DAMPING (default) + | 1 = include Rayleigh damping" + +**Theory** + +If the change in element end displacements for the two DOFs of interest are :math:`\delta_1` and :math:`\delta_2`, the deformation (strain) of the uniaxial material is: + +.. math:: + + \epsilon = \sqrt{\delta_1^2 + \delta_2^2} + +If the resulting force (stress from the uniaxial material) is :math:`\Sigma`, the forces in the two directions are: + +.. math:: + + F_1 = \frac{\Sigma \cdot \delta_1}{\epsilon}, \quad F_2 = \frac{\Sigma \cdot \delta_2}{\epsilon} + +When :math:`\epsilon = 0`, the forces are computed using :math:`\Sigma` and the last committed set of displacements that were not zero. + +.. note:: + + The valid queries to this element when creating an ElementRecorder object are 'force' and 'material matArg1 matArg2 ...'. + +.. seealso:: + + `Notes (OpenSees wiki) `_ + +.. admonition:: Example + + The following example constructs a CoupledZeroLength element with tag **1** between nodes **2** and **4**, coupling directions **5** and **6**, with material tag **7** (from the OpenSees wiki). + + 1. **Tcl Code** + + .. code-block:: tcl + + element coupledZeroLength 1 2 4 5 6 7 + + 2. **Python Code** + + .. code-block:: python + + ops.element('CoupledZeroLength', 1, 2, 4, 5, 6, 7) + +Code developed by: |fmk| From 012dc9e8a0258a0a45cdde49683ddcafaa37d31a Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:03:11 -0800 Subject: [PATCH 03/35] docs(consolidate): add zeroLengthContact element from OpenSeesPyDoc and wiki Co-authored-by: Cursor --- .../model/elements/zeroLengthContact.rst | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 source/user/manual/model/elements/zeroLengthContact.rst diff --git a/source/user/manual/model/elements/zeroLengthContact.rst b/source/user/manual/model/elements/zeroLengthContact.rst new file mode 100644 index 00000000..625c600a --- /dev/null +++ b/source/user/manual/model/elements/zeroLengthContact.rst @@ -0,0 +1,69 @@ +.. _zeroLengthContact: + +zeroLengthContact Element +^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a node-to-node frictional contact element (2D or 3D). The element connects a constrained node and a retained node. The relation follows the Mohr-Coulomb law: :math:`T = \mu N + c`, where :math:`T` is tangential force, :math:`N` is normal force, :math:`\mu` is friction coefficient, and :math:`c` is cohesion. + +**2D:** + +.. function:: element zeroLengthContact2D $eleTag $cNode $rNode $Kn $Kt $mu -normal $Nx $Ny + +**3D:** + +.. function:: element zeroLengthContact3D $eleTag $cNode $rNode $Kn $Kt $mu $c $dir + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $eleTag, |integer|, unique element object tag + $cNode $rNode, |integer|, constrained and retained node tags + $Kn, |float|, penalty in normal direction + $Kt, |float|, penalty in tangential direction + $mu, |float|, friction coefficient + $Nx $Ny, |float|, (2D) normal vector components + $c, |float|, (3D) cohesion (not available in 2D) + $dir, |integer|, "(3D) out-normal of retained plane: 1 = +X, 2 = +Y, 3 = +Z" + +.. note:: + + #. The tangent from the contact element is non-symmetric; use a non-symmetric system solver. + #. For 2D contact, nodes must have 2 DOF; for 3D contact, nodes must have 3 DOF. + #. The out-normal of the master (retained) plane is assumed unchanged during analysis. + +.. seealso:: + + `Notes (OpenSees wiki) `_ + +.. admonition:: Example + + **2D:** Contact element with tag **1** between constrained node **2** and retained node **4**, normal direction (0, -1). + + 1. **Tcl Code** + + .. code-block:: tcl + + element zeroLengthContact2D 1 2 4 1e8 1e8 0.3 -normal 0 -1 + + 2. **Python Code** + + .. code-block:: python + + ops.element('zeroLengthContact2D', 1, 2, 4, 1e8, 1e8, 0.3, '-normal', 0, -1) + + **3D:** Contact element with tag **1**, cohesion **0**, normal in +Z. + + 1. **Tcl Code** + + .. code-block:: tcl + + element zeroLengthContact3D 1 2 4 1e8 1e8 0.3 0.0 3 + + 2. **Python Code** + + .. code-block:: python + + ops.element('zeroLengthContact3D', 1, 2, 4, 1e8, 1e8, 0.3, 0.0, 3) + +Code developed by: **Gang Wang**, Geomatrix From 3e61c0a55a7329351947681bfda578ba8468e939 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:03:12 -0800 Subject: [PATCH 04/35] docs(consolidate): add zeroLengthContactNTS2D element from OpenSeesPyDoc and wiki Co-authored-by: Cursor --- .../model/elements/zeroLengthContactNTS2D.rst | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 source/user/manual/model/elements/zeroLengthContactNTS2D.rst diff --git a/source/user/manual/model/elements/zeroLengthContactNTS2D.rst b/source/user/manual/model/elements/zeroLengthContactNTS2D.rst new file mode 100644 index 00000000..4e4ee015 --- /dev/null +++ b/source/user/manual/model/elements/zeroLengthContactNTS2D.rst @@ -0,0 +1,51 @@ +.. _zeroLengthContactNTS2D: + +zeroLengthContactNTS2D Element +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a node-to-segment (NTS) frictional contact element for 2D analysis. The relation follows the Mohr-Coulomb frictional law: :math:`T = N \times \tan(\phi)`, where :math:`T` is tangential force, :math:`N` is normal force, and :math:`\phi` is friction angle. + +.. function:: element zeroLengthContactNTS2D $eleTag -sNdNum $sNdNum -mNdNum $mNdNum -Nodes $nodeTags $kn $kt $phi + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $eleTag, |integer|, unique element object tag + $sNdNum, |integer|, number of slave nodes + $mNdNum, |integer|, number of master nodes + $nodeTags, |integerList|, slave and master node tags (counterclockwise order) + $kn, |float|, penalty in normal direction + $kt, |float|, penalty in tangential direction + $phi, |float|, friction angle in degrees + +.. note:: + + #. Slave and master nodes must have 2 DOF and be entered in counterclockwise order. + #. The tangent from the contact element is non-symmetric; use a non-symmetric system solver if convergence is difficult. + #. The contact normal is computed automatically (no predefined normal vector required). + #. The element supports large deformations. + +.. seealso:: + + `Notes (OpenSees wiki) `_ + +.. admonition:: Example + + From the OpenSees wiki: element with tag **1**, 6 slave and 6 master nodes, node tags as listed, kn = kt = 1e8, friction angle 16°. + + 1. **Tcl Code** + + .. code-block:: tcl + + element zeroLengthContactNTS2D 1 -sNdNum 6 -mNdNum 6 -Nodes 5 10 12 3 9 11 1 4 2 8 7 6 1e8 1e8 16 + + 2. **Python Code** + + .. code-block:: python + + ops.element('zeroLengthContactNTS2D', 1, '-sNdNum', 6, '-mNdNum', 6, '-Nodes', 5, 10, 12, 3, 9, 11, 1, 4, 2, 8, 7, 6, 1e8, 1e8, 16) + +**References:** Wriggers, P., *Computational Contact Mechanics*, John Wiley & Sons, 2002. + +Code developed by: `Roozbeh G. Mikola `_, UC Berkeley and `N. Sitar `_, UC Berkeley From d2980543d0a60494c7b9b439ac6efcd87d7e55fe Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:03:13 -0800 Subject: [PATCH 05/35] docs(consolidate): add zeroLengthInterface2D element from OpenSeesPyDoc and wiki Co-authored-by: Cursor --- .../model/elements/zeroLengthInterface2D.rst | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 source/user/manual/model/elements/zeroLengthInterface2D.rst diff --git a/source/user/manual/model/elements/zeroLengthInterface2D.rst b/source/user/manual/model/elements/zeroLengthInterface2D.rst new file mode 100644 index 00000000..d2e3f2d2 --- /dev/null +++ b/source/user/manual/model/elements/zeroLengthInterface2D.rst @@ -0,0 +1,51 @@ +.. _zeroLengthInterface2D: + +zeroLengthInterface2D Element +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a node-to-segment (NTS) interface element for 2D analysis. It can handle any number of DOFs (e.g. beam-solid, solid-solid, beam-beam contact), unlike zeroLengthContactNTS2D which is for 2 DOF nodes. The relation follows the Mohr-Coulomb law: :math:`T = N \times \tan(\phi)`. + +.. function:: element zeroLengthInterface2D $eleTag -sNdNum $sNdNum -mNdNum $mNdNum -dof $sdof $mdof -Nodes $nodeTags $kn $kt $phi + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $eleTag, |integer|, unique element object tag + $sNdNum, |integer|, number of secondary nodes + $mNdNum, |integer|, number of primary nodes + $sdof $mdof, |integer|, secondary and primary degree of freedom + $nodeTags, |integerList|, secondary and primary node tags (counterclockwise order) + $kn, |float|, penalty in normal direction + $kt, |float|, penalty in tangential direction + $phi, |float|, friction angle in degrees + +.. note:: + + #. Secondary and primary nodes must have 2 DOF and be entered in counterclockwise order. + #. The tangent from the contact element is non-symmetric; use a non-symmetric system solver if convergence is difficult. + #. The contact normal is computed automatically. The element supports large deformations and different DOF types (beam-beam, beam-solid, solid-solid). + +.. seealso:: + + `Notes (OpenSees wiki) `_ + +.. admonition:: Example + + From the OpenSees wiki: element with tag **1**, 6 secondary and 6 primary nodes, dof 2 and 3, node tags as listed, Kn = Kt = 1e8, friction angle 16°. + + 1. **Tcl Code** + + .. code-block:: tcl + + element zeroLengthInterface2D 1 -sNdNum 6 -mNdNum 6 -dof 2 3 -Nodes 5 10 12 3 9 11 1 4 2 8 7 6 1e8 1e8 16 + + 2. **Python Code** + + .. code-block:: python + + ops.element('zeroLengthInterface2D', 1, '-sNdNum', 6, '-mNdNum', 6, '-dof', 2, 3, '-Nodes', 5, 10, 12, 3, 9, 11, 1, 4, 2, 8, 7, 6, 1e8, 1e8, 16) + +**References:** Wriggers, P., *Computational Contact Mechanics*, John Wiley & Sons, 2002. + +Code developed by: `Roozbeh G. Mikola `_, UC Berkeley and `N. Sitar `_, UC Berkeley From 527bcc312f1147e2ba0179812de9a52a1e84ec2e Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:03:14 -0800 Subject: [PATCH 06/35] docs(consolidate): add zeroLengthImpact3D element from OpenSeesPyDoc and wiki Co-authored-by: Cursor --- .../model/elements/zeroLengthImpact3D.rst | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 source/user/manual/model/elements/zeroLengthImpact3D.rst diff --git a/source/user/manual/model/elements/zeroLengthImpact3D.rst b/source/user/manual/model/elements/zeroLengthImpact3D.rst new file mode 100644 index 00000000..6a7f24a2 --- /dev/null +++ b/source/user/manual/model/elements/zeroLengthImpact3D.rst @@ -0,0 +1,51 @@ +.. _zeroLengthImpact3D: + +zeroLengthImpact3D Element +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command constructs a node-to-node zero-length contact element in 3D to simulate impact/pounding and friction. It extends zeroLengthContact3D with ImpactMaterial-style behavior (Hertz impact model). The element is fast-converging and can be used for surface-to-surface contact by connecting nodes on the constrained surface to nodes on the retained surface. + +.. function:: element zeroLengthImpact3D $eleTag $cNode $rNode $direction $initGap $frictionRatio $Kt $Kn $Kn2 $Delta_y $cohesion + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $eleTag, |integer|, unique element object tag + $cNode $rNode, |integer|, constrained and retained node tags + $direction, |integer|, "out-normal of master plane: 1 = +X, 2 = +Y, 3 = +Z" + $initGap, |float|, initial gap between master and slave + $frictionRatio, |float|, friction ratio in tangential directions + $Kt, |float|, penalty in tangential directions + $Kn, |float|, penalty in normal direction + $Kn2, |float|, penalty in normal direction after yielding (Hertz) + $Delta_y, |float|, yield deformation (Hertz impact model) + $cohesion, |float|, cohesion (zero if none) + +.. note:: + + #. End nodes should be in a 3 DOF domain. See OpenSees documentation and forums for using 3 DOF and 6 DOF together (example scripts are on the wiki). + #. This element is built on zeroLengthContact3D; all notes for that element apply (retained/constrained nodes, DOF, etc.). + #. The tangent is non-symmetric; use a non-symmetric solver if needed. + +.. seealso:: + + `Notes (OpenSees wiki) `_, `ZeroLengthContact `_, `ImpactMaterial `_ + +.. admonition:: Example + + The following constructs a zeroLengthImpact3D element with tag **1** between constrained node **2** and retained node **4**, normal in +Z, zero gap, friction 0.3, penalties 1e6 (Kt, Kn), Kn2 = 2e6, Delta_y = 0.001, zero cohesion. + + 1. **Tcl Code** + + .. code-block:: tcl + + element zeroLengthImpact3D 1 2 4 3 0.0 0.3 1e6 1e6 2e6 0.001 0.0 + + 2. **Python Code** + + .. code-block:: python + + ops.element('zeroLengthImpact3D', 1, 2, 4, 3, 0.0, 0.3, 1e6, 1e6, 2e6, 0.001, 0.0) + +Code developed by: **Dr. Arash E. Zaghi** and **Majid Cashany**, University of Connecticut (UConn) From ac6e8610f55944cc4b6747d44d715dfaa958a3ab Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:03:25 -0800 Subject: [PATCH 07/35] docs(consolidate): add Corotational Truss element from OpenSeesPyDoc and wiki Co-authored-by: Cursor --- .../model/elements/CorotationalTruss.rst | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 source/user/manual/model/elements/CorotationalTruss.rst diff --git a/source/user/manual/model/elements/CorotationalTruss.rst b/source/user/manual/model/elements/CorotationalTruss.rst new file mode 100644 index 00000000..32316549 --- /dev/null +++ b/source/user/manual/model/elements/CorotationalTruss.rst @@ -0,0 +1,58 @@ +.. _corotationalTruss: + +Corotational Truss Element +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a corotational truss element object. The corotational formulation accounts for geometric nonlinearity (large displacements). There are two ways to construct the element: by specifying an area and a UniaxialMaterial, or by specifying a Section. + +.. function:: element corotTruss $eleTag $iNode $jNode $A $matTag <-rho $rho> <-cMass> <-doRayleigh $rFlag> + + Construct a corotational truss element with cross-sectional area and a UniaxialMaterial. + +.. function:: element corotTrussSection $eleTag $iNode $jNode $secTag <-rho $rho> <-cMass> <-doRayleigh $rFlag> + + Construct a corotational truss element with a Section identifier. + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $eleTag, |integer|, unique element object tag + $iNode $jNode, |integer|, end node tags + $A, |float|, cross-sectional area of element + $matTag, |integer|, tag associated with previously-defined UniaxialMaterial + $secTag, |integer|, tag associated with previously-defined Section + $rho, |float|, mass per unit length (optional, default = 0.0) + -cMass, |string|, use consistent mass matrix (optional; default is lumped) + $rFlag, |integer|, "| Rayleigh damping flag (optional, default = 0) + | 0 = NO RAYLEIGH DAMPING (default) + | 1 = include Rayleigh damping" + +.. note:: + + #. When constructed with a UniaxialMaterial object, the corotational truss element considers strain-rate effects and is suitable for use as a damping element. + #. The valid queries when creating an ElementRecorder object are 'axialForce,' 'stiff,' 'deformations,' 'material matArg1 matArg2...' and 'section sectArg1 sectArg2...' + #. CorotTruss does not include Rayleigh damping by default. + #. For backward compatibility, ``element corotTruss $eleTag $iNode $jNode $secTag`` still creates a CorotTrussSection element. + +.. seealso:: + + `Notes (OpenSees wiki) `_ + +.. admonition:: Example + + The following example constructs a corotational truss element with tag **1** between nodes **2** and **4**, area **5.5**, and material tag **9**. + + 1. **Tcl Code** + + .. code-block:: tcl + + element corotTruss 1 2 4 5.5 9 + + 2. **Python Code** + + .. code-block:: python + + ops.element('corotTruss', 1, 2, 4, 5.5, 9) + +Code developed by: |mhs| From 031ba9de80e9f4d376d611e8b445203ca3543b77 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:25:08 -0800 Subject: [PATCH 08/35] docs(consolidate): add Two Node Link element from OpenSeesPyDoc and wiki Co-authored-by: Cursor --- .../manual/model/elements/TwoNodeLink.rst | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 source/user/manual/model/elements/TwoNodeLink.rst diff --git a/source/user/manual/model/elements/TwoNodeLink.rst b/source/user/manual/model/elements/TwoNodeLink.rst new file mode 100644 index 00000000..a25c66cb --- /dev/null +++ b/source/user/manual/model/elements/TwoNodeLink.rst @@ -0,0 +1,69 @@ +.. _twoNodeLink: + +Two Node Link Element +^^^^^^^^^^^^^^^^^^^^^ + +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. It can have 1 to 6 degrees of freedom; only the transverse and rotational DOFs are coupled when the element has non-zero length. For non-zero length you can optionally specify how P-Delta moments (around local x and y) are distributed among moment at node i, moment at node j, and shear couple (the three ratios sum to 1), and the shear center as a fraction of the element length from node i. The element does not contribute to Rayleigh damping by default. For non-zero length the local x-axis is from nodal geometry unless ``-orient`` is given; for zero length the geometry is ignored and orientation vectors define the spring directions. + +.. function:: element twoNodeLink $eleTag $iNode $jNode -mat $matTags -dir $dirs <-orient $x1 $x2 $x3 $y1 $y2 $y3> <-pDelta $Mratios> <-shearDist $sDratios> <-doRayleigh> <-mass $m> + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $eleTag, |integer|, unique element object tag + $iNode $jNode, |integer|, end node tags + $matTags, |integerList|, tags of previously-defined UniaxialMaterial objects + $dirs, |integerList|, "| material directions: + | 2D: 1,2 = translation along local x,y; 3 = rotation about local z + | 3D: 1,2,3 = translation along local x,y,z; 4,5,6 = rotation about local x,y,z" + $x1 $x2 $x3, |float|, (optional) global components defining local x-axis + $y1 $y2 $y3, |float|, (optional) global components defining local y-axis + $Mratios, |floatList|, "| P-Delta ratios: 2D size 2, 3D size 4 + | ([My_iNode, My_jNode] or [My_iNode, My_jNode, Mz_iNode, Mz_jNode]); each pair ≤ 1" + $sDratios, |floatList|, "| center of rotation from iNode as fraction of length (2D: 1 value, 3D: [dy, dz]); + | range 0 to 1; default [0.5, 0.5]" + -doRayleigh, |string|, include Rayleigh damping (optional) + $m, |float|, element mass (optional, default = 0.0) + +.. note:: + + If the element has zero length and orientation vectors are not specified, the local axes coincide with the global axes. Otherwise the local z-axis is the cross product of the x- and y-vectors. + + The valid queries when creating an ElementRecorder are 'force,' 'localForce,' 'basicForce,' 'localDisplacement,' 'basicDisplacement' and 'material $matNum matArg1 matArg2 ...'. + +**Relationship to zeroLength** + +The twoNodeLink can be thought of as a zeroLength element with length. Unlike zeroLength, the local x-axis for non-zero length is taken from the vector between the two nodes, so you do not need to specify orientation unless you want to override it. The element is often used for dampers but also applies to other uncoupled force-deformation responses. When both translational and rotational springs are used, the **shear distance** (``-shearDist``) is the center of rotation as a fraction of the element length; it couples the moment-rotation response to lateral displacement. For zeroLength, lateral displacement depends only on the translational spring; for twoNodeLink it also depends on the rotational spring and the shear distance (default 0.5). With section-based response (e.g. fiber sections), twoNodeLink can model coupled axial, shear, and flexural behavior efficiently. + +.. seealso:: + + `Notes (OpenSees wiki) `_ + + `Two Node Link's Awakening (Portwood Digital) `_ for more on comparison with zeroLength and flexural response. + +.. admonition:: Example + + From the OpenSees wiki: 2D link with tag **1** between nodes **1** and **2**, materials **1**, **2**, **3** in directions **1**, **2**, **3**. 3D link with tag **1**, materials in directions **1**, **2**, **6**. + + 1. **Tcl Code** + + .. code-block:: tcl + + # 2D + element twoNodeLink 1 1 2 -mat 1 2 3 -dir 1 2 3 + + # 3D + element twoNodeLink 1 1 2 -mat 1 2 3 -dir 1 2 6 + + 2. **Python Code** + + .. code-block:: python + + # 2D + ops.element('twoNodeLink', 1, 1, 2, '-mat', 1, 2, 3, '-dir', 1, 2, 3) + + # 3D + ops.element('twoNodeLink', 1, 1, 2, '-mat', 1, 2, 3, '-dir', 1, 2, 6) + +Code developed by: |andreas| From 92a14e6026afad0c1b939ab1be72f6b194edc9bd Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:57:46 -0800 Subject: [PATCH 09/35] Docs: add PathIndependent uniaxial material wrapper Co-authored-by: Cursor --- .../uniaxialMaterials/PathIndependent.rst | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/PathIndependent.rst diff --git a/source/user/manual/material/uniaxialMaterials/PathIndependent.rst b/source/user/manual/material/uniaxialMaterials/PathIndependent.rst new file mode 100644 index 00000000..3754cbc7 --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/PathIndependent.rst @@ -0,0 +1,33 @@ +.. _PathIndependent: + +PathIndependent Material Wrapper +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a PathIndependent uniaxial material wrapper. The wrapper does not call commitState() on the wrapped material, so the stress-strain response is path-independent: the response depends only on the current strain, not on the loading history. + +.. function:: uniaxialMaterial PathIndependent $matTag $otherTag + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $otherTag, |integer|, tag of a previously-defined UniaxialMaterial + +.. admonition:: Example + + 1. **Tcl Code** + + .. code-block:: tcl + + uniaxialMaterial Elastic 1 100.0 + uniaxialMaterial PathIndependent 2 1 + + 2. **Python Code** + + .. code-block:: python + + ops.uniaxialMaterial('Elastic', 1, 100.0) + ops.uniaxialMaterial('PathIndependent', 2, 1) + +Code developed by: |mhs| From 580eceff061858f42f1ee9b6e98fb90146fbaf09 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:57:46 -0800 Subject: [PATCH 10/35] Docs: add TensionOnly uniaxial material wrapper Co-authored-by: Cursor --- .../uniaxialMaterials/TensionOnly.rst | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/TensionOnly.rst diff --git a/source/user/manual/material/uniaxialMaterials/TensionOnly.rst b/source/user/manual/material/uniaxialMaterials/TensionOnly.rst new file mode 100644 index 00000000..b46b798f --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/TensionOnly.rst @@ -0,0 +1,35 @@ +.. _TensionOnly: + +TensionOnly Material Wrapper +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a TensionOnly uniaxial material wrapper. The wrapper returns zero stress and zero tangent when the wrapped material would return negative stress; it does not call ``commitState()`` on the wrapped material when stress is negative. So only tensile (positive) stress is returned. + +.. function:: uniaxialMaterial TensionOnly $matTag $otherTag <-min $minStrain> <-max $maxStrain> + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $otherTag, |integer|, tag of a previously-defined UniaxialMaterial + $minStrain, |float|, (optional) minimum strain limit + $maxStrain, |float|, (optional) maximum strain limit + +.. admonition:: Example + + 1. **Tcl Code** + + .. code-block:: tcl + + uniaxialMaterial Elastic 1 100.0 + uniaxialMaterial TensionOnly 2 1 + + 2. **Python Code** + + .. code-block:: python + + ops.uniaxialMaterial('Elastic', 1, 100.0) + ops.uniaxialMaterial('TensionOnly', 2, 1) + +Code developed by: |mhs| From 1053c398d78bf9da78de89654123463ee87995c7 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:57:47 -0800 Subject: [PATCH 11/35] Docs: add MinMax uniaxial material wrapper Co-authored-by: Cursor --- .../material/uniaxialMaterials/MinMax.rst | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/MinMax.rst diff --git a/source/user/manual/material/uniaxialMaterials/MinMax.rst b/source/user/manual/material/uniaxialMaterials/MinMax.rst new file mode 100644 index 00000000..d74b0609 --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/MinMax.rst @@ -0,0 +1,39 @@ +.. _MinMax: + +MinMax Material Wrapper +^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a MinMax uniaxial material wrapper. The wrapper forwards strain to the wrapped material and returns its stress and tangent until the material strain goes above a maximum or below a minimum. Once that condition is met in ``commitState()``, the wrapper stops updating the wrapped material (the material is treated as failed). + +.. function:: uniaxialMaterial MinMax $matTag $otherTag <-min $minStrain> <-max $maxStrain> + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $otherTag, |integer|, tag of a previously-defined UniaxialMaterial + $minStrain, |float|, (optional) minimum strain; default -1.0e16 + $maxStrain, |float|, (optional) maximum strain; default 1.0e16 + +.. note:: + + After the strain limit is exceeded, the wrapper no longer calls the wrapped material. + +.. admonition:: Example + + 1. **Tcl Code** + + .. code-block:: tcl + + uniaxialMaterial Hardening 1 3.0 1.0 0.1 + uniaxialMaterial MinMax 2 1 -min -0.8 + + 2. **Python Code** + + .. code-block:: python + + ops.uniaxialMaterial('Hardening', 1, 3.0, 1.0, 0.1) + ops.uniaxialMaterial('MinMax', 2, 1, '-min', -0.8) + +Code developed by: |mhs| From 9b3598643120830c94455d812e2a72041ad33fc9 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:57:48 -0800 Subject: [PATCH 12/35] Docs: add SimpleFracture uniaxial material wrapper Co-authored-by: Cursor --- .../uniaxialMaterials/SimpleFracture.rst | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/SimpleFracture.rst diff --git a/source/user/manual/material/uniaxialMaterials/SimpleFracture.rst b/source/user/manual/material/uniaxialMaterials/SimpleFracture.rst new file mode 100644 index 00000000..512ff6f0 --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/SimpleFracture.rst @@ -0,0 +1,34 @@ +.. _SimpleFracture: + +SimpleFracture Material Wrapper +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a SimpleFracture uniaxial material wrapper. The wrapper imposes tensile fracture on the wrapped material: after the strain exceeds a specified maximum tensile strain, the wrapper provides compressive stress based on an estimate of the elastic strain. + +.. function:: uniaxialMaterial SimpleFracture $matTag $otherTag $maxStrain + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $otherTag, |integer|, tag of a previously-defined UniaxialMaterial + $maxStrain, |float|, maximum tensile strain (fracture strain) + +.. admonition:: Example + + 1. **Tcl Code** + + .. code-block:: tcl + + uniaxialMaterial Hardening 1 3.0 1.0 0.1 + uniaxialMaterial SimpleFracture 2 1 0.8 + + 2. **Python Code** + + .. code-block:: python + + ops.uniaxialMaterial('Hardening', 1, 3.0, 1.0, 0.1) + ops.uniaxialMaterial('SimpleFracture', 2, 1, 0.8) + +Code developed by: |mhs| From e37c450fbc7bb2f3d5e0794832b9aa161d4396ce Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:57:49 -0800 Subject: [PATCH 13/35] Docs: add InitStrain uniaxial material wrapper Co-authored-by: Cursor --- .../uniaxialMaterials/InitialStrain.rst | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/InitialStrain.rst diff --git a/source/user/manual/material/uniaxialMaterials/InitialStrain.rst b/source/user/manual/material/uniaxialMaterials/InitialStrain.rst new file mode 100644 index 00000000..514dc719 --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/InitialStrain.rst @@ -0,0 +1,38 @@ +.. _InitialStrain: + +InitStrain Material Wrapper +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct an InitStrain (or InitialStrain) uniaxial material wrapper. The wrapper imposes an initial strain on the wrapped material so that the effective strain seen by the wrapped material is the applied strain plus the initial strain. After the constructor, no special state is maintained. + +.. function:: uniaxialMaterial InitStrain $matTag $otherTag $eps0 + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $otherTag, |integer|, tag of a previously-defined UniaxialMaterial + $eps0, |float|, initial strain + +.. note:: + + It is good practice to run one analysis step with dt = 0 when using initial strain (and initial stress) wrappers so that the model is in equilibrium. + +.. admonition:: Example + + 1. **Tcl Code** + + .. code-block:: tcl + + uniaxialMaterial Hardening 1 3.0 1.0 0.1 + uniaxialMaterial InitStrain 2 1 -0.1 + + 2. **Python Code** + + .. code-block:: python + + ops.uniaxialMaterial('Hardening', 1, 3.0, 1.0, 0.1) + ops.uniaxialMaterial('InitStrain', 2, 1, -0.1) + +Code developed by: |mhs| From 7e8aa277ef8d701ef2fd88f79a7b21b62958388b Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:57:50 -0800 Subject: [PATCH 14/35] Docs: add InitStress uniaxial material wrapper Co-authored-by: Cursor --- .../uniaxialMaterials/InitialStress.rst | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/InitialStress.rst diff --git a/source/user/manual/material/uniaxialMaterials/InitialStress.rst b/source/user/manual/material/uniaxialMaterials/InitialStress.rst new file mode 100644 index 00000000..99ddb036 --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/InitialStress.rst @@ -0,0 +1,38 @@ +.. _InitialStress: + +InitStress Material Wrapper +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct an InitStress (or InitialStress) uniaxial material wrapper. The wrapper imposes an initial stress on the wrapped material. After the constructor, the wrapper passes through the wrapped material response with the initial stress offset. + +.. function:: uniaxialMaterial InitStress $matTag $otherTag $sig0 + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $otherTag, |integer|, tag of a previously-defined UniaxialMaterial + $sig0, |float|, initial stress + +.. note:: + + Run one analysis step with dt = 0 (e.g. static with integrator LoadControl 0.0) so that initial stresses are in equilibrium. + +.. admonition:: Example + + 1. **Tcl Code** + + .. code-block:: tcl + + uniaxialMaterial Hardening 1 3.0 1.0 0.1 + uniaxialMaterial InitStress 2 1 0.3 + + 2. **Python Code** + + .. code-block:: python + + ops.uniaxialMaterial('Hardening', 1, 3.0, 1.0, 0.1) + ops.uniaxialMaterial('InitStress', 2, 1, 0.3) + +Code developed by: |mhs| From 8357cc43accfd0e97af502cc0a8df6eacbb31a12 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:57:53 -0800 Subject: [PATCH 15/35] Docs: add Fatigue uniaxial material wrapper Co-authored-by: Cursor --- .../material/uniaxialMaterials/Fatigue.rst | 91 +++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/Fatigue.rst diff --git a/source/user/manual/material/uniaxialMaterials/Fatigue.rst b/source/user/manual/material/uniaxialMaterials/Fatigue.rst new file mode 100644 index 00000000..f3c9747f --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/Fatigue.rst @@ -0,0 +1,91 @@ +.. _Fatigue: + +Fatigue Material Wrapper +^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a Fatigue uniaxial material wrapper. The wrapper uses a modified rainflow cycle-counting algorithm to accumulate damage in the wrapped material using Miner's rule, based on Coffin-Manson log-log relationships for low-cycle fatigue. It does not change the stress-strain (or force-deformation) response of the wrapped material until fatigue life is exhausted; then the wrapper returns zero stress and zero tangent. + +.. function:: uniaxialMaterial Fatigue $matTag $otherTag <-E0 $e0> <-m $m> <-min $epsmin> <-max $epsmax> + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $otherTag, |integer|, tag of a previously-defined UniaxialMaterial + $e0, |float|, (optional) strain at which one cycle causes failure; default 0.191 + $m, |float|, (optional) slope of Coffin-Manson curve in log-log space; default -0.458 + $epsmin, |float|, (optional) global minimum strain/deformation for failure; default -1e16 + $epsmax, |float|, (optional) global maximum strain/deformation for failure; default 1e16 + +Description +""""""""""" + +The model accounts for low-cycle fatigue. A modified rainflow cycle counter tracks strain amplitudes and is used with a linear strain-accumulation model (Miner's rule) and Coffin-Manson relationships. When the damage level reaches 1.0, the force (or stress) of the wrapped material is set to zero (numerically 1e-8). If failure is triggered in compression, the stress is dropped at the next zero-force crossing. The material treats each point as the last point of the history for damage tracking; if failure is not triggered, that pseudo-peak is discarded. Failure can also be triggered by exceeding the optional minimum or maximum strain limits (defaults are very large so that only fatigue controls). The default E0 and m are calibrated from low-cycle fatigue tests on European steel sections (Ballio and Castiglioni 1995); see Uriz (2005) for calibration details. + +Valid recorder responses for the wrapped material are ``stress``, ``tangent``, ``strain``, ``stressStrain``, and ``damage``. The stress, strain, and tangent options must be supported by the wrapped material. + +Damage recorder +""""""""""""""" + +To record fatigue damage, use the element recorder with the ``damage`` response. + +**Fiber section elements:** The argument after ``material`` (or ``fiber``) is the **fiber index**, not the material tag. Using ``material`` or ``fiber`` gives the same result. To target a fiber by coordinates, add one more argument after ``fiber`` (y and z, or the appropriate coordinate). + +**Truss elements:** Use ``material`` **without** a tag after it. Adding a material tag after ``material`` will not work. + +.. code-block:: tcl + + # Fiber section: record damage of 1st fiber (index 0) — "material" and "fiber" equivalent + recorder Element -xml Damage1.out -time -ele 1 2 section 1 material 0 damage + recorder Element -xml Damage2.out -time -ele 1 2 section 1 fiber 0 damage + + # Fiber section: record damage of fiber near center by coordinates + recorder Element -xml Damage3.out -time -ele 1 2 section 1 fiber 0.1 0.1 damage + + # Truss: use "material" with no tag + recorder Element -file Damage4.out -time -ele 1 material damage + +.. code-block:: python + + # Fiber section: record damage of 1st fiber + ops.recorder('Element', '-xml', 'Damage1.out', '-time', '-ele', 1, 2, 'section', 1, 'material', 0, 'damage') + + # Truss: use "material" with no tag + ops.recorder('Element', '-file', 'Damage4.out', '-time', '-ele', 1, 'material', 'damage') + +.. note:: + + For theory and implementation details see Uriz (2005) and the OpenSees wiki. + +.. seealso:: + + `Fatigue Material (OpenSees wiki) `_ + +.. admonition:: Example + + Wrapping Steel01 with default fatigue parameters (E0 = 0.191, m = -0.458): + + 1. **Tcl Code** + + .. code-block:: tcl + + uniaxialMaterial Steel01 1 50.0 2000.0 0.01 + uniaxialMaterial Fatigue 2 1 + # with explicit defaults: uniaxialMaterial Fatigue 2 1 -E0 0.191 -m -0.458 + + 2. **Python Code** + + .. code-block:: python + + ops.uniaxialMaterial('Steel01', 1, 50.0, 2000.0, 0.01) + ops.uniaxialMaterial('Fatigue', 2, 1) + # with explicit defaults: ops.uniaxialMaterial('Fatigue', 2, 1, '-E0', 0.191, '-m', -0.458) + +References +"""""""""" + +- Uriz, P. (2005). "Towards Earthquake Resistant Design of Concentrically Braced Steel Structures," Ph.D. Dissertation, UC Berkeley. +- Ballio, G., and Castiglioni, C. A. (1995). "A Unified Approach for the Design of Steel Structures under Low and/or High Cycle Fatigue." Journal of Constructional Steel Research, 34, 75-101. + +Code developed by: Patxi Uriz, Exponent; modifications by Kevin Mackie. From 7efcd2f9b85ddd6277d644bb5301e6ebe97556b5 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:57:54 -0800 Subject: [PATCH 16/35] Docs: add Damper uniaxial material wrapper Co-authored-by: Cursor --- .../material/uniaxialMaterials/Damper.rst | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/Damper.rst diff --git a/source/user/manual/material/uniaxialMaterials/Damper.rst b/source/user/manual/material/uniaxialMaterials/Damper.rst new file mode 100644 index 00000000..8a26ec54 --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/Damper.rst @@ -0,0 +1,34 @@ +.. _Damper: + +Damper Material Wrapper +^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a Damper uniaxial material wrapper. The wrapper uses the stress-strain response of any UniaxialMaterial as a **stress versus strain-rate** relationship for damping. The conversion is done by passing strain rate as strain and the material tangent as the damping tangent in the state determination. + +.. function:: uniaxialMaterial Damper $matTag $otherTag <-factors $fact1 $fact2 ...> + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $otherTag, |integer|, tag of a previously-defined UniaxialMaterial + $fact1 ..., |float|, (optional) factors for multiple materials + +.. admonition:: Example + + 1. **Tcl Code** + + .. code-block:: tcl + + uniaxialMaterial Elastic 1 100.0 + uniaxialMaterial Damper 2 1 + + 2. **Python Code** + + .. code-block:: python + + ops.uniaxialMaterial('Elastic', 1, 100.0) + ops.uniaxialMaterial('Damper', 2, 1) + +Code developed by: |mhs| From 33947d89c1d42e5a0453bc676b62a3a14f91f714 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:57:55 -0800 Subject: [PATCH 17/35] Docs: add Parallel uniaxial material (composite) Co-authored-by: Cursor --- .../material/uniaxialMaterials/Parallel.rst | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/Parallel.rst diff --git a/source/user/manual/material/uniaxialMaterials/Parallel.rst b/source/user/manual/material/uniaxialMaterials/Parallel.rst new file mode 100644 index 00000000..c45dd61b --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/Parallel.rst @@ -0,0 +1,36 @@ +.. _Parallel: + +Parallel Material (Composite) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a Parallel uniaxial material. It is a Composite-pattern aggregation of UniaxialMaterial objects acting in parallel: the same strain is applied to each component, and the combined stress and tangent are the (optionally weighted) sum of the component responses. + +.. function:: uniaxialMaterial Parallel $matTag $tag1 $tag2 ... <-factors $fact1 $fact2 ...> + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $tag1 ..., |integer|, tags of previously-defined UniaxialMaterial objects + $fact1 ..., |float|, (optional) weighting factors; if omitted, all factors are 1 + +.. admonition:: Example + + 1. **Tcl Code** + + .. code-block:: tcl + + uniaxialMaterial Elastic 1 100.0 + uniaxialMaterial Elastic 2 50.0 + uniaxialMaterial Parallel 3 1 2 + + 2. **Python Code** + + .. code-block:: python + + ops.uniaxialMaterial('Elastic', 1, 100.0) + ops.uniaxialMaterial('Elastic', 2, 50.0) + ops.uniaxialMaterial('Parallel', 3, 1, 2) + +Code developed by: |fmk| (ParallelModel); |mhs| (ParallelMaterial). From 2558d1202138709f2270198ee71978f9c5fde86d Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:57:56 -0800 Subject: [PATCH 18/35] Docs: add Series uniaxial material (composite) Co-authored-by: Cursor --- .../material/uniaxialMaterials/Series.rst | 37 +++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/Series.rst diff --git a/source/user/manual/material/uniaxialMaterials/Series.rst b/source/user/manual/material/uniaxialMaterials/Series.rst new file mode 100644 index 00000000..4e0337a5 --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/Series.rst @@ -0,0 +1,37 @@ +.. _Series: + +Series Material (Composite) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a Series uniaxial material. It is a Composite-pattern aggregation of UniaxialMaterial objects in series: the same stress is carried by each component, and the combined strain and flexibility are determined by iterative state determination (same approach as in force-based beam elements). + +.. function:: uniaxialMaterial Series $matTag $tag1 $tag2 ... $tagN <-iter $maxIter $tol> + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $tag1 ..., |integer|, tags of previously-defined UniaxialMaterial objects + $maxIter, |integer|, (optional) maximum iterations for state determination; default 1 + $tol, |float|, (optional) convergence tolerance; default 1e-10 + +.. admonition:: Example + + 1. **Tcl Code** + + .. code-block:: tcl + + uniaxialMaterial Elastic 1 100.0 + uniaxialMaterial Elastic 2 50.0 + uniaxialMaterial Series 3 1 2 + + 2. **Python Code** + + .. code-block:: python + + ops.uniaxialMaterial('Elastic', 1, 100.0) + ops.uniaxialMaterial('Elastic', 2, 50.0) + ops.uniaxialMaterial('Series', 3, 1, 2) + +Code developed by: |mhs| From ca9a0a1499ed9df144dde76ca24636db3f0ab034 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:57:57 -0800 Subject: [PATCH 19/35] Docs: add Penalty uniaxial material wrapper Co-authored-by: Cursor --- .../material/uniaxialMaterials/Penalty.rst | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/Penalty.rst diff --git a/source/user/manual/material/uniaxialMaterials/Penalty.rst b/source/user/manual/material/uniaxialMaterials/Penalty.rst new file mode 100644 index 00000000..d4a9ea45 --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/Penalty.rst @@ -0,0 +1,43 @@ +.. _Penalty: + +Penalty Material Wrapper +^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a Penalty uniaxial material wrapper. The wrapper adds a small stiffness to its wrapped UniaxialMaterial. This helps avoid a singular stiffness due to perfect plasticity and is a lightweight alternative to placing the wrapped material in parallel with an ElasticMaterial. + +.. function:: uniaxialMaterial Penalty $matTag $otherTag $penalty <-noStress> + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $otherTag, |integer|, tag of a previously-defined UniaxialMaterial + $penalty, |float|, actual stiffness value added to the tangent (and optionally to stress); same units as material tangent + -noStress, |string|, (optional) if given, penalty stiffness is not added to stress, only to tangent + +.. note:: + + Use a small penalty value (the actual stiffness added) so that the response remains dominated by the wrapped material. + +.. admonition:: Example + + 1. **Tcl Code** + + .. code-block:: tcl + + set E 29000.0 + set penalty [expr 0.05 * $E] + uniaxialMaterial Elastic 1 $E + uniaxialMaterial Penalty 2 1 $penalty + + 2. **Python Code** + + .. code-block:: python + + E = 29000.0 + penalty = 0.05 * E + ops.uniaxialMaterial('Elastic', 1, E) + ops.uniaxialMaterial('Penalty', 2, 1, penalty) + +Code developed by: |mhs| From dad77f099b171eae4bacf43644e3d2488a035cd2 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:57:58 -0800 Subject: [PATCH 20/35] Docs: add Multiplier uniaxial material wrapper Co-authored-by: Cursor --- .../material/uniaxialMaterials/Multiplier.rst | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/Multiplier.rst diff --git a/source/user/manual/material/uniaxialMaterials/Multiplier.rst b/source/user/manual/material/uniaxialMaterials/Multiplier.rst new file mode 100644 index 00000000..68ffb3be --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/Multiplier.rst @@ -0,0 +1,34 @@ +.. _Multiplier: + +Multiplier Material Wrapper +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a Multiplier uniaxial material wrapper. The wrapper multiplies the stress and tangent of its wrapped UniaxialMaterial by a factor. Typical uses include overstrength factors for materials and p-y multipliers for shadowing effects in pile groups. + +.. function:: uniaxialMaterial Multiplier $matTag $otherTag $multiplier + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $otherTag, |integer|, tag of a previously-defined UniaxialMaterial + $multiplier, |float|, factor applied to stress and tangent of the wrapped material + +.. admonition:: Example + + 1. **Tcl Code** + + .. code-block:: tcl + + uniaxialMaterial Elastic 1 100.0 + uniaxialMaterial Multiplier 2 1 0.8 + + 2. **Python Code** + + .. code-block:: python + + ops.uniaxialMaterial('Elastic', 1, 100.0) + ops.uniaxialMaterial('Multiplier', 2, 1, 0.8) + +Code developed by: |mhs| From acaaa2c3bf22fc3b56894c305f3d3b190af3a54b Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 19:58:01 -0800 Subject: [PATCH 21/35] Docs: add wrapper uniaxial materials to uniaxialMaterial toctree Co-authored-by: Cursor --- source/user/manual/material/uniaxialMaterial.rst | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/source/user/manual/material/uniaxialMaterial.rst b/source/user/manual/material/uniaxialMaterial.rst index ab7679d7..0986538e 100644 --- a/source/user/manual/material/uniaxialMaterial.rst +++ b/source/user/manual/material/uniaxialMaterial.rst @@ -89,14 +89,19 @@ The following subsections contain information about **$matType** .. toctree:: :maxdepth: 1 - -.. uniaxialMaterials/Fatigue + + uniaxialMaterials/Fatigue uniaxialMaterials/Parallel uniaxialMaterials/Series + uniaxialMaterials/TensionOnly + uniaxialMaterials/SimpleFracture uniaxialMaterials/InitialStrain uniaxialMaterials/InitialStress uniaxialMaterials/MinMax uniaxialMaterials/PathIndependent + uniaxialMaterials/Damper + uniaxialMaterials/Penalty + uniaxialMaterials/Multiplier #. Other Uniaxial Materials From 3054c8712aac745b568f3fdfd08f0744aa6b9abd Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:06:41 -0800 Subject: [PATCH 22/35] Docs: expand Element recorder with fiber response and sectionX Co-authored-by: Cursor --- source/user/manual/output/ElementRecorder.rst | 67 ++++++++++++++++++- 1 file changed, 66 insertions(+), 1 deletion(-) diff --git a/source/user/manual/output/ElementRecorder.rst b/source/user/manual/output/ElementRecorder.rst index 6bd644eb..9703cf58 100644 --- a/source/user/manual/output/ElementRecorder.rst +++ b/source/user/manual/output/ElementRecorder.rst @@ -3,4 +3,69 @@ Element Recorder ^^^^^^^^^^^^^^^^ -text. \ No newline at end of file +The element recorder is used to record element-level response during an analysis. Output may go to a file, XML, or other targets depending on the arguments. Common responses include ``force``, ``deformation``, and (for elements with sections) section and fiber response. + +.. function:: recorder Element <-file $fileName> <-xml $fileName> ... <-time> <-ele $ele1 $ele2 ...> $responseArgs + +The exact arguments depend on the element type and what you want to record. The following sections describe how to record **fiber** and **section** response for fiber-section and beam-column elements. + +Recording fiber response +"""""""""""""""""""""""" + +For elements that use fiber sections (e.g. **zeroLengthSection**, **forceBeamColumn**, **dispBeamColumn**, **mixedBeamColumn**), you can record the response of a single fiber. What can be recorded in each fiber is defined by the UniaxialMaterial's ``setResponse()`` method. A common option is ``stressStrain``, which gives the fiber stress-strain history. Other options (e.g. ``stress``, ``strain``, ``tangent``, ``damage`` for the Fatigue material) are available when supported by the material. + +You specify *which* fiber to record using one of three options: + +1. **Fiber index** – The index in the section's internal array of fibers (0 to *N*\ :sub:`f` − 1). Use ``fiber`` followed by the index and the response type. + +2. **Fiber closest to section coordinates** – Give the section *y* and *z* coordinates; the recorder uses the fiber closest to that point. Use ``fiber`` followed by *y*, *z*, and the response type. For 2D problems, bending is about the *z*-axis so only *y* matters, but you must still provide a *z* value (e.g. 0). + +3. **Fiber with a given material tag closest to coordinates** – Same as (2), but only among fibers with the specified material tag. Use ``fiber`` followed by *y*, *z*, *matTag*, and the response type. This is useful for sections with overlapping fibers (e.g. steel and concrete) when you want a specific material at a location. + +What comes *before* ``fiber`` depends on the element: + +- **zeroLengthSection** – Use ``section`` then ``fiber`` (there is only one section). + +- **Beam-column elements** (displacement-based, force-based, mixed) – Use ``section`` *secNum* then ``fiber``, where *secNum* is the integration point number (1 to *N*\ :sub:`p` from node *I* to node *J*). Alternatively, use ``sectionX`` *x* then ``fiber`` to select the section closest to coordinate *x* along the element (see :ref:`elementRecorderSectionX`). + +.. code-block:: tcl + + # zeroLengthSection: fiber closest to (y,z), stress-strain + recorder Element -ele 1 -file fiber.out section fiber 0.1 0.0 stressStrain + + # Beam-column: section 1, fiber at (y,z) with material tag 2 (e.g. steel) + recorder Element -ele 1 -file steelFiber.out section 1 fiber -h/2 0 2 stressStrain + +.. code-block:: python + + # zeroLengthSection: fiber closest to (y,z) + ops.recorder('Element', '-ele', 1, '-file', 'fiber.out', 'section', 'fiber', 0.1, 0.0, 'stressStrain') + + # Beam-column: section 1, steel fiber at tension face + ops.recorder('Element', '-ele', 1, '-file', 'steelFiber.out', 'section', 1, 'fiber', -h/2, 0, 2, 'stressStrain') + +.. _elementRecorderSectionX: + +Recording section response by location (sectionX) +""""""""""""""""""""""""""""""""""""""""""""""""" + +For beam-column elements you can record section response (e.g. ``force``, ``deformation``) by **section number** (1 to *N*\ :sub:`p`). The mapping from section number to position depends on the integration rule (e.g. Lobatto, Legendre, or plastic-hinge schemes), so it is not always obvious which number corresponds to a given location along the element. + +You can avoid relying on section numbers by using **sectionX**: give a location *x* in the range [0, *L*] along the element (0 at node *I*, *L* at node *J*). The recorder will use the section **closest** to that *x* coordinate. The remaining arguments after ``sectionX`` *x* are the same as for the usual ``section`` *secNum* recorder (e.g. ``deformation``, ``force``, or ``fiber`` ...). + +.. code-block:: tcl + + # Section closest to x = 25 along the element + recorder Element -ele 1 -file sec25.out sectionX 25 deformation + +.. code-block:: python + + ops.recorder('Element', '-ele', 1, '-file', 'sec25.out', 'sectionX', 25, 'deformation') + +.. note:: + + ``sectionX`` accepts a **single** *x* value per recorder. To record at multiple locations, define multiple recorders or use multiple *x* values in separate recorder commands. + +.. seealso:: + + For recording **fatigue damage** in fiber sections or truss elements, see the damage recorder notes in :ref:`Fatigue`. For a detailed walkthrough of fiber recorders and moment-curvature analysis, see `How to Record Fiber Response (Portwood Digital) `_ and `Section X (Portwood Digital) `_. From 91c5ffb2fb3574c2bdb96f6ded4b248d06a4b010 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:06:44 -0800 Subject: [PATCH 23/35] Docs: add section.rst cross-reference to Element recorder Co-authored-by: Cursor --- source/user/manual/section.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/user/manual/section.rst b/source/user/manual/section.rst index 20f2f9fb..df86a28f 100644 --- a/source/user/manual/section.rst +++ b/source/user/manual/section.rst @@ -20,7 +20,7 @@ The type of section created and the additional arguments required depends on the .. note:: - The valid queries to any section when creating an ElementRecorder are 'force', and 'deformation'. Some sections have additional queries to which they will respond. These are documented in the NOTES section for those sections. + The valid queries to any section when creating an ElementRecorder are 'force', and 'deformation'. Some sections have additional queries to which they will respond. These are documented in the NOTES section for those sections. For recording fiber response (e.g. stressStrain) and for using section location ``sectionX``, see :ref:`elementRecorder`. The following contain information about secType? and the args required for each of the available section types: From 666a0e29e6c1dd23481b3fd0fb5ffcc298cece4b Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:15:23 -0800 Subject: [PATCH 24/35] Docs: add Concrete02IS uniaxial material (Concrete02 with initial stiffness control) Co-authored-by: Cursor --- .../uniaxialMaterials/Concrete02IS.rst | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 source/user/manual/material/uniaxialMaterials/Concrete02IS.rst diff --git a/source/user/manual/material/uniaxialMaterials/Concrete02IS.rst b/source/user/manual/material/uniaxialMaterials/Concrete02IS.rst new file mode 100644 index 00000000..1abb9244 --- /dev/null +++ b/source/user/manual/material/uniaxialMaterials/Concrete02IS.rst @@ -0,0 +1,58 @@ +.. _Concrete02IS: + +Concrete02IS Material (Concrete02 with Initial Stiffness Control) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This command is used to construct a uniaxial concrete material with the same compressive envelope and tension/cyclic behavior as :ref:`Concrete02`, but with **user-defined initial stiffness** *E*\ :sub:`0`. In Concrete02 the initial stiffness is fixed at :math:`E_c = 2f'_c/\varepsilon_{c0}`; Concrete02IS allows any *E*\ :sub:`0` (e.g. :math:`57000\sqrt{f'_c}` or secant stiffness to peak). + +.. function:: uniaxialMaterial Concrete02IS $matTag $E0 $fpc $epsc0 $fpcu $epsU <$lambda $ft $Ets> + +.. csv-table:: + :header: "Argument", "Type", "Description" + :widths: 10, 10, 40 + + $matTag, |integer|, unique material tag + $E0, |float|, initial (elastic) stiffness + $fpc, |float|, concrete compressive strength at 28 days (compression negative) + $epsc0, |float|, concrete strain at maximum strength (negative) + $fpcu, |float|, concrete crushing strength (negative) + $epsU, |float|, concrete strain at crushing strength (negative) + $lambda, |float|, (optional) ratio between unloading slope at epsU and initial slope + $ft, |float|, (optional) tensile strength + $Ets, |float|, (optional) tension softening stiffness (absolute value) + +.. note:: + + Compressive parameters (*fpc*, *epsc0*, *fpcu*, *epsU*) are taken as negative; if given positive, they are converted to negative internally. The input *E*\ :sub:`0` affects the unloading/reloading stiffness in compression. The ascending branch uses the Popovics equation (Concrete02 uses the Hognestad parabola). + +.. admonition:: Example + + 1. **Tcl Code** + + .. code-block:: tcl + + set fc 4000.0 + set epsc0 -0.002 + set fcu -1000.0 + set epscu -0.006 + # Same initial stiffness as Concrete02 + set Ec [expr 2.0*$fc/(-$epsc0)] + uniaxialMaterial Concrete02IS 1 $Ec $fc $epsc0 $fcu $epscu + # With tension and optional parameters + uniaxialMaterial Concrete02IS 2 $Ec $fc $epsc0 $fcu $epscu 0.1 500.0 1738.33 + + 2. **Python Code** + + .. code-block:: python + + fc, epsc0 = 4000.0, -0.002 + fcu, epscu = -1000.0, -0.006 + Ec = 2.0 * fc / (-epsc0) + ops.uniaxialMaterial('Concrete02IS', 1, Ec, fc, epsc0, fcu, epscu) + ops.uniaxialMaterial('Concrete02IS', 2, Ec, fc, epsc0, fcu, epscu, 0.1, 500.0, 1738.33) + +.. seealso:: + + :ref:`Concrete02` (fixed initial stiffness). `Concrete02 with Control of the Initial Stiffness (Portwood Digital) `_. + +Code developed by: Filip Filippou (Concrete02); Nasser Marafi (Concrete02IS, initial stiffness control). From bab501b1f6ac2c958ce001edb658ce82af4fee55 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:15:23 -0800 Subject: [PATCH 25/35] Docs: add non-prismatic beam integration note to beamIntegration.rst Co-authored-by: Cursor --- source/user/manual/model/beamIntegration.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/source/user/manual/model/beamIntegration.rst b/source/user/manual/model/beamIntegration.rst index e55f4f30..8c61b51b 100644 --- a/source/user/manual/model/beamIntegration.rst +++ b/source/user/manual/model/beamIntegration.rst @@ -15,6 +15,8 @@ This command is used to construct an integration object for certain beam element $tag, |integer|, unique beam integration tag. $args, |list|, a list of arguments with number dependent on integration type +Several distributed plasticity integration types (Lobatto, Legendre, Radau, NewtonCotes, Trapezoidal, CompositeSimpson, and others) support **non-prismatic** members: instead of one section tag and *N*, you may pass *N* section tags so that each integration point uses a different section. This allows varying cross-section or reinforcement along the element. See the individual integration pages. + Following are beamIntegration types available in the OpenSees: 1. Integration Methods for Distributed Plasticity. Distributed plasticity methods permit yielding at any integration point along the element length. From ccfedecd2d0585dd688005b50158c8f374728e07 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:15:24 -0800 Subject: [PATCH 26/35] Docs: document non-prismatic option for Lobatto beam integration Co-authored-by: Cursor --- .../manual/model/beamIntegrations/Lobatto.rst | 36 ++++++++++++------- 1 file changed, 24 insertions(+), 12 deletions(-) diff --git a/source/user/manual/model/beamIntegrations/Lobatto.rst b/source/user/manual/model/beamIntegrations/Lobatto.rst index a46fd52d..6ccf4fae 100644 --- a/source/user/manual/model/beamIntegrations/Lobatto.rst +++ b/source/user/manual/model/beamIntegrations/Lobatto.rst @@ -1,36 +1,48 @@ - .. _Lobatto-BeamIntegration: - Lobatto ^^^^^^^ This command is used to create a Gauss-Lobatto beamIntegration object. Gauss-Lobatto integration is the most common approach for evaluating the response of :doc:`ForceBeamColumn` (`Neuenhofer and Filippou 1997`_) because it places an integration point at each end of the element, where bending moments are largest in the absence of interior element loads. -.. function:: beamIntegration 'Lobatto' tag secTag N +Two input forms are supported: + +**Prismatic** – One section for all integration points: + +.. function:: beamIntegration Lobatto tag secTag N + +**Non-prismatic** – One section tag per integration point (section tags are mapped to Lobatto point locations in order from node *I* to node *J*): + +.. function:: beamIntegration Lobatto tag N secTag1 secTag2 ... secTagN .. csv-table:: :header: "Argument", "Type", "Description" :widths: 10, 10, 40 - "$tag", "|integer|", "Unique object tag" - "$sectTag", "|integer|", "A previous-defined section" - "$N", "|integer|", "Number of Integration Points along the elementa" - + tag, |integer|, unique beam integration tag + secTag, |integer|, (prismatic) one previously-defined section for all points + N, |integer|, number of integration points + secTag1 …, |integer|, (non-prismatic) *N* section tags, one per integration point + +.. note:: -.. admonition:: Example: + The non-prismatic form allows different sections along the element length (e.g. different reinforcement or cross-sections) without using FixedLocation or plastic-hinge integration. Same option exists for Legendre, Radau, NewtonCotes, Trapezoidal, CompositeSimpson, and other distributed plasticity methods. - The following examples demonstrate the command in Tcl and Python script to add a Lobatto beam integration with tag 2 and 6 integration points that uses the previously defined section whose tag is 1. +.. admonition:: Example + + Prismatic: 6 integration points, one section (tag 1). Non-prismatic: 3 sections (tags 1, 2, 1) at the 3 Lobatto points. 1. **Tcl Code** .. code-block:: tcl - beamIntegration 'Lobatto' 2 1 6 - + beamIntegration Lobatto 2 1 6 + beamIntegration Lobatto 3 3 1 2 1 2. **Python Code** .. code-block:: python - beamIntegration('Lobatto',2,1,6) + ops.beamIntegration('Lobatto', 2, 1, 6) + secTagList = [1, 2, 1] + ops.beamIntegration('Lobatto', 3, len(secTagList), *secTagList) From ad9c0524fa534a3ba1ea5bed10a5ad6057d0cfe0 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:15:25 -0800 Subject: [PATCH 27/35] Docs: document non-prismatic option for Legendre beam integration Co-authored-by: Cursor --- .../model/beamIntegrations/Legendre.rst | 31 ++++++++++--------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/source/user/manual/model/beamIntegrations/Legendre.rst b/source/user/manual/model/beamIntegrations/Legendre.rst index fd542f09..83c3998b 100644 --- a/source/user/manual/model/beamIntegrations/Legendre.rst +++ b/source/user/manual/model/beamIntegrations/Legendre.rst @@ -1,33 +1,36 @@ -Legendre +Legendre ^^^^^^^^ - This command is used to create a Gauss-Legendre beamIntegration object. Gauss-Legendre integration is more accurate than Gauss-Lobatto; however, it is not common in force-based elements because there are no integration points at the element ends. The command places ``N`` Gauss-Legendre integration points along the element. The location and weight of each integration point are tabulated in references on numerical analysis. The force deformation response at each integration point is defined by the section. The order of accuracy for Gauss-Legendre integration is 2N-1. - -.. function:: beamIntegration 'Legendre' tag secTag N +This command is used to create a Gauss-Legendre beamIntegration object. Gauss-Legendre integration is more accurate than Gauss-Lobatto; however, it is not common in force-based elements because there are no integration points at the element ends. The command places *N* Gauss-Legendre integration points along the element. The location and weight of each integration point are tabulated in references on numerical analysis. The order of accuracy is 2*N*−1. + +Two input forms are supported: **prismatic** (one section for all points) and **non-prismatic** (one section tag per integration point). + +.. function:: beamIntegration Legendre tag secTag N + +.. function:: beamIntegration Legendre tag N secTag1 secTag2 ... secTagN .. csv-table:: :header: "Argument", "Type", "Description" :widths: 10, 10, 40 - "$tag", "|integer|", "Unique object tag" - "$sectTag", "|integer|", "A previous-defined section" - "$N", "|integer|", "Number of Integration Points along the elementa" - + tag, |integer|, unique beam integration tag + secTag, |integer|, (prismatic) one previously-defined section + N, |integer|, number of integration points + secTag1 …, |integer|, (non-prismatic) *N* section tags, one per point -.. admonition:: Example: - - The following examples demonstrate the command in Tcl and Python script to add a Legendre beam integration with tag 2 and 6 integration points that uses the previously defined section whose tag is 1. +.. admonition:: Example 1. **Tcl Code** .. code-block:: tcl - beamIntegration 'Legendre' 2 1 6 - + beamIntegration Legendre 2 1 6 + beamIntegration Legendre 3 4 1 2 2 1 2. **Python Code** .. code-block:: python - beamIntegration('Legendre',2,1,6) + ops.beamIntegration('Legendre', 2, 1, 6) + ops.beamIntegration('Legendre', 3, 4, 1, 2, 2, 1) From eff085f741433d482753f16a37f294c125905931 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:15:26 -0800 Subject: [PATCH 28/35] Docs: document non-prismatic option for Radau beam integration Co-authored-by: Cursor --- .../manual/model/beamIntegrations/Radau.rst | 25 +++++++++++-------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/source/user/manual/model/beamIntegrations/Radau.rst b/source/user/manual/model/beamIntegrations/Radau.rst index ca8f8105..5b4090d0 100644 --- a/source/user/manual/model/beamIntegrations/Radau.rst +++ b/source/user/manual/model/beamIntegrations/Radau.rst @@ -11,32 +11,35 @@ To create a Gauss-Radau beamIntegration object. Gauss-Radau integration is not c numerical analysis. The force-deformation response at each integration point is defined by the section. The order of accuracy for Gauss-Radau integration is 2N-2. -.. function:: beamIntegration 'Radau' tag secTag N +Two input forms: prismatic (one section) or non-prismatic (N section tags). + +.. function:: beamIntegration Radau tag secTag N + +.. function:: beamIntegration Radau tag N secTag1 secTag2 ... secTagN .. csv-table:: :header: "Argument", "Type", "Description" :widths: 10, 10, 40 - "$tag", "|integer|", "Unique object tag" - "$sectTag", "|integer|", "A previous-defined section" - "$N", "|integer|", "Number of Integration Points along the elementa" - + tag, |integer|, unique beam integration tag + secTag, |integer|, (prismatic) one previously-defined section + N, |integer|, number of integration points + secTag1 ..., |integer|, (non-prismatic) N section tags, one per point -.. admonition:: Example: - - The following examples demonstrate the command in Tcl and Python script to add a Radau beam integration with tag 2 and 6 integration points that uses the previously defined section whose tag is 1. +.. admonition:: Example 1. **Tcl Code** .. code-block:: tcl - beamIntegration 'Radau' 2 1 6 - + beamIntegration Radau 2 1 6 + beamIntegration Radau 3 4 1 2 2 1 2. **Python Code** .. code-block:: python - beamIntegration('Radau',2,1,6) + ops.beamIntegration('Radau', 2, 1, 6) + ops.beamIntegration('Radau', 3, 4, 1, 2, 2, 1) From e699ed69f679f90e796e4b52579ce708da8012f0 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:15:29 -0800 Subject: [PATCH 29/35] Docs: add Concrete02IS to Concrete Materials toctree Co-authored-by: Cursor --- source/user/manual/material/uniaxialMaterial.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/source/user/manual/material/uniaxialMaterial.rst b/source/user/manual/material/uniaxialMaterial.rst index 0986538e..d0df75ea 100644 --- a/source/user/manual/material/uniaxialMaterial.rst +++ b/source/user/manual/material/uniaxialMaterial.rst @@ -44,6 +44,7 @@ The following subsections contain information about **$matType** uniaxialMaterials/Concrete01 uniaxialMaterials/Concrete02 + uniaxialMaterials/Concrete02IS uniaxialMaterials/Concrete04 uniaxialMaterials/ASDConcrete1D uniaxialMaterials/GMG_CyclicReinforcedConcrete From 07e28353fb4bd7049f7b85f33ba5bce58f13ef08 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:15:30 -0800 Subject: [PATCH 30/35] Docs: document non-prismatic option for NewtonCotes beam integration Co-authored-by: Cursor --- .../model/beamIntegrations/NewtonCotes.rst | 25 +++++++++++-------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/source/user/manual/model/beamIntegrations/NewtonCotes.rst b/source/user/manual/model/beamIntegrations/NewtonCotes.rst index 605c45a5..b1a0e593 100644 --- a/source/user/manual/model/beamIntegrations/NewtonCotes.rst +++ b/source/user/manual/model/beamIntegrations/NewtonCotes.rst @@ -8,32 +8,35 @@ This command creates a Newton-Cotes beamIntegration object. Newton-Cotes places response at each integration point is defined by the section. The order of accuracy for Gauss-Radau integration is N-1. -.. function:: beamIntegration 'NewtonCotes' tag secTag N +Two input forms: **prismatic** (one section) or **non-prismatic** (*N* section tags). + +.. function:: beamIntegration NewtonCotes tag secTag N + +.. function:: beamIntegration NewtonCotes tag N secTag1 secTag2 ... secTagN .. csv-table:: :header: "Argument", "Type", "Description" :widths: 10, 10, 40 - "$tag", "|integer|", "Unique object tag" - "$sectTag", "|integer|", "A previous-defined section" - "$N", "|integer|", "Number of Integration Points along the elementa" - + tag, |integer|, unique beam integration tag + secTag, |integer|, (prismatic) one previously-defined section + N, |integer|, number of integration points + secTag1 …, |integer|, (non-prismatic) *N* section tags, one per point -.. admonition:: Example: - - The following examples demonstrate the command in Tcl and Python script to add a NewtonCotes beam integration with tag 2 and 6 integration points that uses the previously defined section whose tag is 1. +.. admonition:: Example 1. **Tcl Code** .. code-block:: tcl - beamIntegration 'NewtonCotes' 2 1 6 - + beamIntegration NewtonCotes 2 1 6 + beamIntegration NewtonCotes 3 4 1 2 2 1 2. **Python Code** .. code-block:: python - beamIntegration('NewtonCotes',2,1,6) + ops.beamIntegration('NewtonCotes', 2, 1, 6) + ops.beamIntegration('NewtonCotes', 3, 4, 1, 2, 2, 1) From 040c04ae6444bd6f84812849219b1fb8e3546e32 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:15:31 -0800 Subject: [PATCH 31/35] Docs: document non-prismatic option for Trapezoidal beam integration Co-authored-by: Cursor --- .../model/beamIntegrations/Trapezoidal.rst | 25 +++++++++++-------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/source/user/manual/model/beamIntegrations/Trapezoidal.rst b/source/user/manual/model/beamIntegrations/Trapezoidal.rst index 5ecffbd1..03cf2c37 100644 --- a/source/user/manual/model/beamIntegrations/Trapezoidal.rst +++ b/source/user/manual/model/beamIntegrations/Trapezoidal.rst @@ -5,33 +5,36 @@ Trapezoidal Create a Trapezoidal beamIntegration object. -.. function:: beamIntegration 'Trapezoidal' tag secTag N +Two input forms: **prismatic** (one section) or **non-prismatic** (*N* section tags). + +.. function:: beamIntegration Trapezoidal tag secTag N + +.. function:: beamIntegration Trapezoidal tag N secTag1 secTag2 ... secTagN .. csv-table:: :header: "Argument", "Type", "Description" :widths: 10, 10, 40 - "$tag", "|integer|", "Unique object tag" - "$sectTag", "|integer|", "A previous-defined section" - "$N", "|integer|", "Number of Integration Points along the elementa" - + tag, |integer|, unique beam integration tag + secTag, |integer|, (prismatic) one previously-defined section + N, |integer|, number of integration points + secTag1 …, |integer|, (non-prismatic) *N* section tags, one per point -.. admonition:: Example: - - The following examples demonstrate the command in Tcl and Python script to add a Trapezoidal beam integration with tag 2 and 6 integration points that uses the previously defined section whose tag is 1. +.. admonition:: Example 1. **Tcl Code** .. code-block:: tcl - beamIntegration 'Trapezoidal' 2 1 6 - + beamIntegration Trapezoidal 2 1 6 + beamIntegration Trapezoidal 3 4 1 2 2 1 2. **Python Code** .. code-block:: python - beamIntegration('Trapezoidal',2,1,6) + ops.beamIntegration('Trapezoidal', 2, 1, 6) + ops.beamIntegration('Trapezoidal', 3, 4, 1, 2, 2, 1) From d4456896aa55ec7bbf03ce78d67a5d0de22ae8cb Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:15:32 -0800 Subject: [PATCH 32/35] Docs: document non-prismatic option for CompositeSimpson beam integration Co-authored-by: Cursor --- .../beamIntegrations/CompositeSimpson.rst | 25 +++++++++++-------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/source/user/manual/model/beamIntegrations/CompositeSimpson.rst b/source/user/manual/model/beamIntegrations/CompositeSimpson.rst index 160b8145..b3299b92 100644 --- a/source/user/manual/model/beamIntegrations/CompositeSimpson.rst +++ b/source/user/manual/model/beamIntegrations/CompositeSimpson.rst @@ -4,33 +4,36 @@ CompositeSimpson To create a CompositeSimpson beamIntegration object. -.. function:: beamIntegration 'CompositeSimpson' tag secTag N +Two input forms: **prismatic** (one section) or **non-prismatic** (*N* section tags). + +.. function:: beamIntegration CompositeSimpson tag secTag N + +.. function:: beamIntegration CompositeSimpson tag N secTag1 secTag2 ... secTagN .. csv-table:: :header: "Argument", "Type", "Description" :widths: 10, 10, 40 - "$tag", "|integer|", "Unique object tag" - "$sectTag", "|integer|", "A previous-defined section" - "$N", "|integer|", "Number of Integration Points along the elementa" - + tag, |integer|, unique beam integration tag + secTag, |integer|, (prismatic) one previously-defined section + N, |integer|, number of integration points + secTag1 …, |integer|, (non-prismatic) *N* section tags, one per point -.. admonition:: Example: - - The following examples demonstrate the command in Tcl and Python script to add a CompositeSimpson beam integration with tag 2 and 6 integration points that uses the previously defined section whose tag is 1. +.. admonition:: Example 1. **Tcl Code** .. code-block:: tcl - beamIntegration 'CompositeSimpson' 2 1 6 - + beamIntegration CompositeSimpson 2 1 6 + beamIntegration CompositeSimpson 3 4 1 2 2 1 2. **Python Code** .. code-block:: python - beamIntegration('CompositeSimpson',2,1,6) + ops.beamIntegration('CompositeSimpson', 2, 1, 6) + ops.beamIntegration('CompositeSimpson', 3, 4, 1, 2, 2, 1) From 0b81a135466c0a51d5ee38083adacd1f00ce9d95 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:36:48 -0800 Subject: [PATCH 33/35] Docs: add trapezoidal beam loads to eleLoad (Plain pattern load commands only) Co-authored-by: Cursor --- source/user/manual/model/eleLoad.rst | 2 +- .../PlainPatternloadcommands/eleLoad.rst | 83 +++++++++++++------ 2 files changed, 59 insertions(+), 26 deletions(-) diff --git a/source/user/manual/model/eleLoad.rst b/source/user/manual/model/eleLoad.rst index c68dc34f..9fc7e8f2 100644 --- a/source/user/manual/model/eleLoad.rst +++ b/source/user/manual/model/eleLoad.rst @@ -68,4 +68,4 @@ When NDM=3, the beam column elements all accept eleLoad commands of the followin pattern('Plain',1,1) eleLoad('-ele',3, '-type', -beamUniform', W/width) -Code Developed by: |fmk| \ No newline at end of file +Code Developed by: |fmk| diff --git a/source/user/manual/model/pattern/PlainPatternloadcommands/eleLoad.rst b/source/user/manual/model/pattern/PlainPatternloadcommands/eleLoad.rst index c68dc34f..a50b7a97 100644 --- a/source/user/manual/model/pattern/PlainPatternloadcommands/eleLoad.rst +++ b/source/user/manual/model/pattern/PlainPatternloadcommands/eleLoad.rst @@ -7,38 +7,50 @@ The eleLoad command is used to construct an ElementalLoad object and add it to t .. function:: eleLoad $eleLoad $arg1 $arg2 $arg3 .... -The beam column elements all accept eleLoad commands of the following form: +The beam column elements all accept eleLoad commands of the following form. + +**Uniform (full span)** – NDM=2: .. code:: eleLoad -ele $eleTag1 <$eleTag2 ....> -type -beamUniform $Wy <$Wx> +**Trapezoidal (partial span, 2D)** – Load varies linearly between *a/L* and *b/L* (normalized, 0 to 1). Transverse and axial intensity at start (*Wy*, *Wx*) and at end (*Wyb*, *Wxb*). Supported by 2D ``elasticBeamColumn`` and ``forceBeamColumn``: + +.. code:: + + eleLoad -ele $eleTag1 <$eleTag2 ....> -type -beamUniform $Wya $Wxa $aOverL $bOverL $Wyb $Wxb + +**Point load** – NDM=2: + .. code:: eleLoad -range $eleTag1 $eleTag2 -type -beamPoint $Py $xL <$Px> -When NDM=3, the beam column elements all accept eleLoad commands of the following form: +When NDM=3, the beam column elements accept: .. code:: eleLoad -ele $eleTag1 <$eleTag2 ....> -type -beamUniform $Wy $Wz <$Wx> +For trapezoidal loads in 3D, use *Wy* *Wz* *Wx* *aOverL* *bOverL* *Wyb* *Wzb* *Wxb*. The 3D ``elasticBeamColumn`` implementation may be triangular rather than trapezoidal; you can combine two element loads (e.g. one uniform, one triangular) to obtain a trapezoid. + .. code:: eleLoad -range $eleTag1 $eleTag2 -type -beamPoint $Py $Pz $xL <$Px> -.. csv-table:: +.. csv-table:: :header: "Argument", "Type", "Description" :widths: 10, 10, 40 - $eleTags, |intList|, tags of PREVIOUSLY DEFINED element - $Wx, |float|, mag of uniformily distributed ref load acting in direction along member length - $Wy, |float|, mag of uniformily distributed ref load acting in local y direction of element - $Wz, |float|, mag of uniformily distributed ref load acting in local z direction of element - $Py, |float|, mag of ref point load acting in direction along member length - $Py, |float|, mag of ref point load acting in local y direction of element - $Pz, |float|, mag of ref point load acting in local z direction of element - $xL location of point load relative to node I, prescribed as fraction of element length + $eleTags, |intList|, tags of previously defined elements + $Wy $Wx, |float|, (uniform) distributed load in local y and x (force/length) + $Wya $Wxa, |float|, (trapezoidal) load intensity at start (a) in local y and x + $aOverL $bOverL, |float|, (trapezoidal) start and end of segment, fraction of length (0–1) + $Wyb $Wxb, |float|, (trapezoidal) load intensity at end (b) in local y and x + $Wz, |float|, (3D) distributed load in local z + $Py $Pz $Px, |float|, (point) ref load in local y, z, x + $xL, |float|, location of point load as fraction of element length from node I .. note:: @@ -49,23 +61,44 @@ When NDM=3, the beam column elements all accept eleLoad commands of the followin At the moment, eleLoads do not work with 3D beam-column elements if Corotational geometric transformation is used. -.. admonition: Example +.. seealso:: + + Trapezoidal beam loads + +.. admonition:: Example + + Uniform distributed load; trapezoidal load on segment from 0.2*L* to 0.8*L* (2D). + + **Tcl:** + + .. code-block:: tcl -.. code:: tcl + set width 20.0 + set W 4000.0 + set wya -0.5 + set wxa 0.0 + set aOverL 0.2 + set bOverL 0.8 + set wyb -1.0 + set wxb 0.0 + timeSeries Linear 1 + pattern Plain 1 1 { + eleLoad -ele 3 -type -beamUniform [expr -$W/$width] + eleLoad -ele 4 -type -beamUniform $wya $wxa $aOverL $bOverL $wyb $wxb + } - set width 20.0 - set W 4000.0; - timeSeries Linear 1 - pattern Plain 1 1 { - eleLoad -ele 3 -type -beamUniform [expr -$W/$width] - } + **Python:** -.. code:: tcl + .. code-block:: python - width = 20.0; - W = 4000.0; - timeSeries('Linear', 1) - pattern('Plain',1,1) - eleLoad('-ele',3, '-type', -beamUniform', W/width) + width = 20.0 + W = 4000.0 + wya, wxa = -0.5, 0.0 + aOverL, bOverL = 0.2, 0.8 + wyb, wxb = -1.0, 0.0 + ops.timeSeries('Linear', 1) + ops.pattern('Plain', 1, 1) + ops.eleLoad('-ele', 3, '-type', 'beamUniform', -W/width) + ops.eleLoad('-ele', 4, '-type', 'beamUniform', wya, wxa, aOverL, bOverL, wyb, wxb) Code Developed by: |fmk| \ No newline at end of file From f52580203f399023d08c8b6304cf2d2ae7cc2f03 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:42:54 -0800 Subject: [PATCH 34/35] Docs: enable Elastic in Standard Uniaxial Materials toctree Co-authored-by: Cursor --- source/user/manual/material/uniaxialMaterial.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/user/manual/material/uniaxialMaterial.rst b/source/user/manual/material/uniaxialMaterial.rst index d0df75ea..d430e09e 100644 --- a/source/user/manual/material/uniaxialMaterial.rst +++ b/source/user/manual/material/uniaxialMaterial.rst @@ -61,8 +61,8 @@ The following subsections contain information about **$matType** .. toctree:: :maxdepth: 1 - -.. uniaxialMaterials/Elastic + + uniaxialMaterials/Elastic uniaxialMaterials/ElasticPP uniaxialMaterials/ElasticPP_Gap uniaxialMaterials/ElasticNoTension From b11548105e00946d8739d08164df5660594e8c82 Mon Sep 17 00:00:00 2001 From: gaaraujo Date: Sat, 21 Feb 2026 20:56:15 -0800 Subject: [PATCH 35/35] Docs: add visible Tcl/Python labels to code blocks in modified manual pages Use doc-standard '1. Tcl Code' / '2. Python Code' to match rest of manual. - ElementRecorder: add labels before each code block pair (no label before) - Fatigue: add labels for damage recorder section; keep example labels - eleLoad, beam integrations, uniaxial materials: keep existing numbered format Co-authored-by: Cursor --- .../user/manual/material/uniaxialMaterials/Fatigue.rst | 4 ++++ .../model/pattern/PlainPatternloadcommands/eleLoad.rst | 4 ++-- source/user/manual/output/ElementRecorder.rst | 10 +++++++++- 3 files changed, 15 insertions(+), 3 deletions(-) diff --git a/source/user/manual/material/uniaxialMaterials/Fatigue.rst b/source/user/manual/material/uniaxialMaterials/Fatigue.rst index f3c9747f..d7e9e066 100644 --- a/source/user/manual/material/uniaxialMaterials/Fatigue.rst +++ b/source/user/manual/material/uniaxialMaterials/Fatigue.rst @@ -34,6 +34,8 @@ To record fatigue damage, use the element recorder with the ``damage`` response. **Truss elements:** Use ``material`` **without** a tag after it. Adding a material tag after ``material`` will not work. +1. **Tcl Code** + .. code-block:: tcl # Fiber section: record damage of 1st fiber (index 0) — "material" and "fiber" equivalent @@ -46,6 +48,8 @@ To record fatigue damage, use the element recorder with the ``damage`` response. # Truss: use "material" with no tag recorder Element -file Damage4.out -time -ele 1 material damage +2. **Python Code** + .. code-block:: python # Fiber section: record damage of 1st fiber diff --git a/source/user/manual/model/pattern/PlainPatternloadcommands/eleLoad.rst b/source/user/manual/model/pattern/PlainPatternloadcommands/eleLoad.rst index a50b7a97..d2c1edb8 100644 --- a/source/user/manual/model/pattern/PlainPatternloadcommands/eleLoad.rst +++ b/source/user/manual/model/pattern/PlainPatternloadcommands/eleLoad.rst @@ -69,7 +69,7 @@ For trapezoidal loads in 3D, use *Wy* *Wz* *Wx* *aOverL* *bOverL* *Wyb* *Wzb* *W Uniform distributed load; trapezoidal load on segment from 0.2*L* to 0.8*L* (2D). - **Tcl:** + 1. **Tcl Code** .. code-block:: tcl @@ -87,7 +87,7 @@ For trapezoidal loads in 3D, use *Wy* *Wz* *Wx* *aOverL* *bOverL* *Wyb* *Wzb* *W eleLoad -ele 4 -type -beamUniform $wya $wxa $aOverL $bOverL $wyb $wxb } - **Python:** + 2. **Python Code** .. code-block:: python diff --git a/source/user/manual/output/ElementRecorder.rst b/source/user/manual/output/ElementRecorder.rst index 9703cf58..a9c88c28 100644 --- a/source/user/manual/output/ElementRecorder.rst +++ b/source/user/manual/output/ElementRecorder.rst @@ -28,6 +28,8 @@ What comes *before* ``fiber`` depends on the element: - **Beam-column elements** (displacement-based, force-based, mixed) – Use ``section`` *secNum* then ``fiber``, where *secNum* is the integration point number (1 to *N*\ :sub:`p` from node *I* to node *J*). Alternatively, use ``sectionX`` *x* then ``fiber`` to select the section closest to coordinate *x* along the element (see :ref:`elementRecorderSectionX`). +1. **Tcl Code** + .. code-block:: tcl # zeroLengthSection: fiber closest to (y,z), stress-strain @@ -36,6 +38,8 @@ What comes *before* ``fiber`` depends on the element: # Beam-column: section 1, fiber at (y,z) with material tag 2 (e.g. steel) recorder Element -ele 1 -file steelFiber.out section 1 fiber -h/2 0 2 stressStrain +2. **Python Code** + .. code-block:: python # zeroLengthSection: fiber closest to (y,z) @@ -53,18 +57,22 @@ For beam-column elements you can record section response (e.g. ``force``, ``defo You can avoid relying on section numbers by using **sectionX**: give a location *x* in the range [0, *L*] along the element (0 at node *I*, *L* at node *J*). The recorder will use the section **closest** to that *x* coordinate. The remaining arguments after ``sectionX`` *x* are the same as for the usual ``section`` *secNum* recorder (e.g. ``deformation``, ``force``, or ``fiber`` ...). +1. **Tcl Code** + .. code-block:: tcl # Section closest to x = 25 along the element recorder Element -ele 1 -file sec25.out sectionX 25 deformation +2. **Python Code** + .. code-block:: python ops.recorder('Element', '-ele', 1, '-file', 'sec25.out', 'sectionX', 25, 'deformation') .. note:: - ``sectionX`` accepts a **single** *x* value per recorder. To record at multiple locations, define multiple recorders or use multiple *x* values in separate recorder commands. + ``sectionX`` accepts a **single** *x* value per recorder. To record at multiple locations, define multiple recorders. .. seealso::