diff --git a/source/user/manual/material/uniaxialMaterial.rst b/source/user/manual/material/uniaxialMaterial.rst
index ab7679d7..d430e09e 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
@@ -60,8 +61,8 @@ The following subsections contain information about **$matType**
 
 .. toctree::
       :maxdepth: 1
-		 
-..    uniaxialMaterials/Elastic
+
+      uniaxialMaterials/Elastic
       uniaxialMaterials/ElasticPP
       uniaxialMaterials/ElasticPP_Gap
       uniaxialMaterials/ElasticNoTension
@@ -89,14 +90,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
 
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) <https://portwooddigital.com/2021/11/06/concrete02-with-control-of-the-initial-stiffness/>`_.
+
+Code developed by: Filip Filippou (Concrete02); Nasser Marafi (Concrete02IS, initial stiffness control).
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|
diff --git a/source/user/manual/material/uniaxialMaterials/Fatigue.rst b/source/user/manual/material/uniaxialMaterials/Fatigue.rst
new file mode 100644
index 00000000..d7e9e066
--- /dev/null
+++ b/source/user/manual/material/uniaxialMaterials/Fatigue.rst
@@ -0,0 +1,95 @@
+.. _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.
+
+1. **Tcl Code**
+
+.. 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
+
+2. **Python Code**
+
+.. 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) <http://opensees.berkeley.edu/wiki/index.php/Fatigue_Material>`_
+
+.. 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.
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|
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|
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|
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|
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).
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|
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|
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|
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|
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|
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.
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)
 
 
 
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)
 
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)
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)
 
 
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)
 
 
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)
 
 
 
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/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) <http://opensees.berkeley.edu/wiki/index.php/Corotational_Truss_Element>`_
+
+.. 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|
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) <http://opensees.berkeley.edu/wiki/index.php/CoupledZeroLength_Element>`_
+
+.. 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|
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) <http://opensees.berkeley.edu/wiki/index.php/Truss_Element>`_
+
+.. 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|
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) <http://opensees.berkeley.edu/wiki/index.php/Two_Node_Link_Element>`_
+
+   `Two Node Link's Awakening (Portwood Digital) <https://portwooddigital.com/2025/02/23/two-node-links-awakening/>`_ 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|
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) <http://opensees.berkeley.edu/wiki/index.php/ZeroLengthContact_Element>`_
+
+.. 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
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) <http://opensees.berkeley.edu/wiki/index.php/ZeroLengthContactNTS2D>`_
+
+.. 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 <http://www.roozbehgm.com/>`_, UC Berkeley and `N. Sitar <http://www.ce.berkeley.edu/~sitar/>`_, UC Berkeley
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) <http://opensees.berkeley.edu/wiki/index.php/ZeroLengthImpact3D>`_, `ZeroLengthContact <https://opensees.berkeley.edu/wiki/index.php/ZeroLengthContact_Element>`_, `ImpactMaterial <https://opensees.berkeley.edu/wiki/index.php/Impact_Material>`_
+
+.. 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)
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) <http://opensees.berkeley.edu/wiki/index.php/ZeroLengthInterface2D>`_
+
+.. 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 <http://www.roozbehgm.com/>`_, UC Berkeley and `N. Sitar <http://www.ce.berkeley.edu/~sitar/>`_, UC Berkeley
diff --git a/source/user/manual/model/pattern/PlainPatternloadcommands/eleLoad.rst b/source/user/manual/model/pattern/PlainPatternloadcommands/eleLoad.rst
index c68dc34f..d2c1edb8 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).
+
+   1. **Tcl Code**
+
+   .. 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]
-   }
+   2. **Python Code**
 
-.. 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
diff --git a/source/user/manual/output/ElementRecorder.rst b/source/user/manual/output/ElementRecorder.rst
index 6bd644eb..a9c88c28 100644
--- a/source/user/manual/output/ElementRecorder.rst
+++ b/source/user/manual/output/ElementRecorder.rst
@@ -3,4 +3,77 @@
 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`).
+
+1. **Tcl Code**
+
+.. 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
+
+2. **Python Code**
+
+.. 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`` ...).
+
+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.
+
+.. 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) <https://portwooddigital.com/2021/07/25/how-to-record-fiber-response/>`_ and `Section X (Portwood Digital) <https://portwooddigital.com/2021/11/07/section-x/>`_.
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: