cmp

Author: claudioperez

content/en/benchmarks/_index.md

@@ -0,0 +1,5 @@
+---
+title: Benchmarks
+description: Benchmarks
+---
+

content/en/benchmarks/frame-0002/index.md

@@ -0,0 +1,39 @@
+---
+title: Transverse loading
+description: >-
+    In this case the cantilever beam is subjected only to a transverse force
+    of $\boldsymbol{F} = 10 \, \mathbf{E}_2$ in a single step.
+---
+
+## End Force
+
+In this case the cantilever beam is subjected only to a transverse force
+of $\boldsymbol{F} = 10 \, \mathbf{E}_2$ in a single step. The
+simulation uses the following geometric and material properties from the
+literature: 
+
+$$
+\begin{array}{lr}
+L  =&    1 \\
+E  =&   10 \\
+\hphantom{.}
+% G  =   GAv/A
+\end{array}
+\qquad 
+\begin{array}{lr}
+A  =&   10^7 \\
+I  =&    1   \\
+J  =&   10^7 \\
+\end{array}
+$$
+
+Two values for the shear modulus $G$ are used with a shear
+stiffness $GA$ of $500$ and $10$, respectively, the latter representing
+the case with significant shear deformations.
+Table (#tab:transv) presents the numerical tip displacements and the
+analytic solution from <cite key="batista2016closedform"></cite> using Jacobi elliptic
+functions and accounting for flexural and shear deformations. The
+analysis uses both 2-node and 4-node elements. For the sake of brevity,
+the results are reported only for the variants using the same
+parameterization as the wrapped element's interpolation.
+

content/en/benchmarks/frame-0003/index.md

@@ -0,0 +1,98 @@
+---
+title: Rigid Offsets
+meta:
+  title: "A verification example for frame element offset handling in OpenSees"
+tags: ["Frame", "Offset"]
+weight: 30
+draft: false
+description: >-
+  This example tests the effect of rigid joint offsets in a diamond-shaped frame.
+  The analytical solution is known, and the test is used to verify the correct
+  treatment of offset geometry in a 3D frame element.
+downloads:
+  Tcl: ["test-linear.tcl"]
+---
+
+
+This test case consists of a simple two-node frame element arranged in a diamond pattern.
+Rigid offsets at both ends rotate the element relative to the applied force direction.
+This configuration is highly sensitive to geometric assumptions, making it ideal
+for verifying the implementation of joint offsets in 3D frame elements.
+
+
+A vertical unit load is applied at the free end, and a single analysis step is performed:
+
+{{< tabs tabTotal="2" >}}
+{{% tab name="Python" %}}
+```python
+    m.pattern("Plain", 1, "Linear", loads={2: (0, 1, 0, 0, 0, 0)})
+
+    P = -4 * L**2 / (E * I)
+    m.integrator("LoadControl", P)
+    m.analysis("Static")
+    m.test("NormDispIncr", 1e-8, 2)
+    m.analyze(1)
+
+    print(P / diamond_solution(E*I, E*A, L, off=off) / L)
+    print(m.nodeDisp(1))
+    print(m.nodeDisp(2))
+    print(m.nodeDisp(2, 2) / L)
+    return m
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+## Validation
+
+Recall the stiffness $\boldsymbol{K}_e$ of a linear 2D Euler-Bernoulli beam:
+
+$$
+\boldsymbol{K}_e = \begin{bmatrix}
+EA/L_e &       0 &       0 \\
+    0 & 4 EI/L_e & 2 EI/L_e \\
+    0 & 2 EI/L_e & 4 EI/L_e \\
+\end{bmatrix}
+$$
+
+This is transformed into the angled configuration using the transformation:
+
+$$
+\boldsymbol{A}_v = \begin{bmatrix}
+-dX/L_e   &  dY/L_e   & 0 &  dX/L_e   \\
+-dY/L_e^2 & -dX/L_e^2 & 0 &  dY/L_e^2 \\
+-dY/L_e^2 & -dX/L_e^2 & 1 &  dY/L_e^2 \\
+\end{bmatrix}
+$$
+
+and joint offsets are similarly applied with:
+
+$$
+\boldsymbol{A}_o = 
+\begin{bmatrix}
+0 & 1 &               0 \\
+1 & 0 & -L_o/\sqrt{2}   \\
+0 & 0 &               1 \\
+0 & 0 &  L_o/\sqrt{2}   \\
+\end{bmatrix}
+$$
+
+```python
+import numpy as np
+def diamond_solution(EI, EA, L, off=0):
+    Le = L - 2*off
+    dX = dY = Le/np.sqrt(2)
+    Ag = np.array([[-dX/Le   ,  dY/Le   , 0,  dX/Le   ],
+                   [-dY/Le**2, -dX/Le**2, 0,  dY/Le**2],
+                   [-dY/Le**2, -dX/Le**2, 1,  dY/Le**2]])
+    Ao = np.array([[0, 1,              0],
+                   [1, 0,-off/np.sqrt(2)],
+                   [0, 0,              1],
+                   [0, 0, off/np.sqrt(2)]])
+    A  = Ag @ Ao
+    Ke = np.array([[EA/Le,       0,       0],
+                   [    0, 4*EI/Le, 2*EI/Le],
+                   [    0, 2*EI/Le, 4*EI/Le]])
+    K = A.T @ Ke @ A
+    return 1 / np.linalg.solve(K, [1, 0, 0])
+```
+

content/en/benchmarks/frame-0003/test-linear.tcl

@@ -0,0 +1,23 @@
+
+pragma openseespy
+
+model  -ndm 3 -ndf 6
+
+set off [expr 0.1*5/sqrt(2)]
+
+node 1 0 0 0 
+node 2 3.5355339059327373 3.5355339059327373 0 
+fix  1 0 1 1 1 1 1 
+fix  2 1 0 1 1 0 0 
+geomTransf Linear 1 0 0 1 -jntOffset $off $off 0.0   -$off -$off 0.0
+
+section Elastic 1  30 500 -Iy 1 -Iz 1 -G 1 -J 1.5
+element forceBeamColumn 1 1 2 -transform 1 -section 1 -shear 0
+
+pattern Plain 1 Linear {load 2 0 1 0 0 0 0}
+integrator LoadControl -3.3333333333333335 
+analysis Static 
+analyze 1 
+
+verify value "[expr [nodeDisp 2 2]/5]" -0.3371259258188718
+

content/en/benchmarks/frame-0004/index.md

@@ -0,0 +1,4 @@
+---
+title: Frame element loading
+---
+

content/en/benchmarks/frame-0004/test_BeamLoad2D.tcl

@@ -0,0 +1,103 @@
+#
+# Simply supported beam with distributed loads
+#
+
+verify about "2D Frame element loads"
+set E 30000.0
+set A 20.0
+set I 1400.0
+
+set L  100.0
+set beta 0.2
+set lp [expr $beta*$L]
+
+# Point loads
+set P 200.0
+set N 150.0
+set aL 0.4
+set a [expr $aL*$L]
+
+# Distributed loads
+set wt 3.0
+set wa 2.0
+
+set nIP 5
+
+set elements {1 2 3 5}
+
+foreach element $elements {
+	
+    model basic -ndm 2 -ndf 3
+	
+    node 1 0.0 0.0
+    node 2  $L 0.0
+    
+    fix 1 1 1 0
+    fix 2 0 1 0
+
+    section Elastic 1 $E $A $I
+    
+    geomTransf Linear 1
+    
+    switch $element {
+	1 {
+	    puts "   ElasticBeamColumn"
+	    element elasticBeamColumn 1 1 2 $A $E $I 1
+	}
+	2 {
+	    puts "   DispBeamColumn"
+	    element dispBeamColumn 1 1 2 $nIP 1 1
+	}
+	3 {
+	    puts "   NonlinearBeamColumn"
+	    element nonlinearBeamColumn 1 1 2 $nIP 1 1
+	}
+	4 {
+	    puts "   BeamWithHinges"
+	    element beamWithHinges 1 1 2 1 $lp 1 $lp $E $A $I 1
+	}
+	5 {
+	    puts "   PrismFrame"
+	    element PrismFrame 1 1 2 $A $E $I 1
+	}
+    }
+    
+    pattern Plain 1 "Constant" {
+	set P2 [expr $P/2]
+	set N2 [expr $N/2]
+	
+	eleLoad -ele 1 -type -beamPoint $P2 $aL $N2
+	eleLoad -ele 1 -type -beamPoint $P2 $aL $N2
+
+	set wt2 [expr $wt/2]
+	set wa2 [expr $wa/2]
+	
+	eleLoad -ele 1 -type -beamUniform $wt2 $wa2
+	eleLoad -ele 1 -type -beamUniform $wt2 $wa2
+    }
+    
+    test NormUnbalance 1.0e-10 10 0
+    algorithm Newton
+    integrator LoadControl 1.0
+    constraints Plain
+    system ProfileSPD
+    numberer Plain
+    analysis Static
+    
+    verify value [analyze 2] 0
+    
+
+    set d1 [expr $aL*$N*$L/($E*$A)]
+    set d2 [expr $wa*pow($L,2)/(2*$E*$A)]
+    verify value [nodeDisp 2 1] [expr $d1+$d2] 1e-6 "axial displacement"
+
+    set V1 [expr $P*(1-$aL)]
+    set d1 [expr -$V1/(6*$E*$I*$L)*($a*$a*$L-2*$a*$L*$L)]
+    set d2 [expr $wt*pow($L,3)/(24*$E*$I)]
+    verify value [nodeDisp 1 3] [expr $d1+$d2] 1e-6 "rotation (node 1)"
+
+    set d1 [expr -$V1/(6*$E*$I*$L)*($a*$a*$L+$a*$L*$L)]
+    verify value [nodeDisp 2 3] [expr $d1-$d2] 1e-6 "rotation (node 2)"
+
+    wipe
+}