OpenSees Example 1a. 2D Elastic Cantilever Column -- Static Pushover
\n",
9 | "
\n",
10 | "\n",
11 | "You can find the original Examples: \n",
12 | "https://opensees.berkeley.edu/wiki/index.php/Examples_Manual \n",
13 | "Original Examples by By Silvia Mazzoni & Frank McKenna, 2006, in Tcl \n",
14 | "Converted to OpenSeesPy by SilviaMazzoni, 2020 \n",
15 | "
\n",
16 | "\n",
17 | "
Simulation Process
\n",
18 | "\n",
19 | "Each example script does the following:\n",
20 | "
define the input motion and all associated parameters, such as scaling and input type
\n",
45 | "
define analysis duration and time increment
\n",
46 | "
define damping
\n",
47 | "
analyze
\n",
48 | "
\n",
49 | "\n",
50 | "Introductory Examples\n",
51 | "The objective of Example 1a and Example 1b is to give an overview of input-file format in OpenSees using simple scripts.\n",
52 | "These scripts do not take advantage of the Tcl scripting capabilities shown in the later examples. However, they do provide starting a place where the input file is similar to that of more familiar Finite-Element Analysis software. Subsequent examples should be used as the basis for user input files.\n",
53 | " "
54 | ]
55 | },
56 | {
57 | "cell_type": "markdown",
58 | "metadata": {},
59 | "source": [
60 | "
OpenSees Example 1a. 2D Elastic Cantilever Column -- Static Pushover
\n",
61 | "Introduction\n",
62 | "Example 1a is a simple model of an elastic cantilever column. \n",
63 | " Objectives of Example 1b \n",
64 | " - overview of basic OpenSees input structure \n",
65 | " - coordinates, boundary conditions, element connectivity, nodal masses, nodal loads, etc. \n",
66 | " - two-node, one element\n",
67 | "\n"
68 | ]
69 | },
70 | {
71 | "cell_type": "code",
72 | "execution_count": 1,
73 | "metadata": {},
74 | "outputs": [
75 | {
76 | "name": "stdout",
77 | "output_type": "stream",
78 | "text": [
79 | "Done!\n"
80 | ]
81 | }
82 | ],
83 | "source": [
84 | "############################################################\n",
85 | "# EXAMPLE: \n",
86 | "# pyEx1a.Canti2D.Push.tcl.py\n",
87 | "# for OpenSeesPy\n",
88 | "# --------------------------------------------------------#\n",
89 | "# by: Silvia Mazzoni, 2020\n",
90 | "# silviamazzoni@yahoo.com\n",
91 | "############################################################\n",
92 | "# This file was obtained from a conversion of the updated Tcl script\n",
93 | "############################################################\n",
94 | "\n",
95 | "# configure Python workspace\n",
96 | "import openseespy.opensees as ops\n",
97 | "import eSEESminiPy\n",
98 | "import os\n",
99 | "import math\n",
100 | "import numpy as numpy\n",
101 | "import matplotlib.pyplot as plt\n",
102 | "ops.wipe()\n",
103 | "# --------------------------------------------------------------------------------------------------\n",
104 | "# Example 1. cantilever 2D\n",
105 | "# static pushover analysis with gravity.\n",
106 | "# all units are in kip, inch, second\n",
107 | "# elasticBeamColumn ELEMENT\n",
108 | "# Silvia Mazzoni and Frank McKenna, 2006\n",
109 | "#\n",
110 | "# ^Y\n",
111 | "# or\n",
112 | "# 2 __\n",
113 | "# or |\n",
114 | "# or |\n",
115 | "# or |\n",
116 | "# (1) 36'\n",
117 | "# or |\n",
118 | "# or |\n",
119 | "# or |\n",
120 | "# =1= ---- -------->X\n",
121 | "#\n",
122 | "\n",
123 | "# SET UP ----------------------------------------------------------------------------\n",
124 | "ops.wipe() # clear opensees model\n",
125 | "ops.model('basic','-ndm',2,'-ndf',3) # 2 dimensions, 3 dof per node\n",
126 | "if not os.path.exists('Data'):\n",
127 | " os.mkdir('Data')\n",
128 | "\n",
129 | "# define GEOMETRY -------------------------------------------------------------\n",
130 | "# nodal coordinates:\n",
131 | "ops.node(1,0,0) # node , X Y\n",
132 | "ops.node(2,0,432)\n",
133 | "\n",
134 | "# Single point constraints -- Boundary Conditions\n",
135 | "ops.fix(1,1,1,1) # node DX DY RZ\n",
136 | "\n",
137 | "# nodal masses:\n",
138 | "ops.mass(2,5.18,0.,0.) # node , Mx My Mz, Mass=Weight/g.\n",
139 | "\n",
140 | "# Define ELEMENTS -------------------------------------------------------------\n",
141 | "# define geometric transformation: performs a linear geometric transformation of beam stiffness\n",
142 | "# and resisting force from the basic system to the global-coordinate system\n",
143 | "ops.geomTransf('Linear',1) # associate a tag to transformation\n",
144 | "\n",
145 | "# connectivity: (make A very large, 10e6 times its actual value)\n",
146 | "# element elasticBeamColumn eleTag iNode jNode A E Iz transfTag\n",
147 | "ops.element('elasticBeamColumn',1,1,2,3600000000,4227,1080000,1) # element elasticBeamColumn 1 1 2 3600000000 4227 1080000 1;\n",
148 | "\n",
149 | "# Define RECORDERS -------------------------------------------------------------\n",
150 | "ops.recorder('Node','-file','Data/DFreeEx1aPush.out','-time','-node',2,'-dof',1,2,3,'disp') # displacements of free nodes\n",
151 | "ops.recorder('Node','-file','Data/DBaseEx1aPush.out','-time','-node',1,'-dof',1,2,3,'disp') # displacements of support nodes\n",
152 | "ops.recorder('Node','-file','Data/RBaseEx1aPush.out','-time','-node',1,'-dof',1,2,3,'reaction') # support reaction\n",
153 | "ops.recorder('Element','-file','Data/FColEx1aPush.out','-time','-ele',1,'globalForce') # element forces -- column\n",
154 | "ops.recorder('Element','-file','Data/DColEx1aPush.out','-time','-ele',1,'deformation') # element deformations -- column\n",
155 | "\n",
156 | "# define GRAVITY -------------------------------------------------------------\n",
157 | "ops.timeSeries('Linear',1) # timeSeries Linear 1;\n",
158 | "# define Load Pattern\n",
159 | "ops.pattern('Plain',1,1) # \n",
160 | "ops.load(2,0.,-2000.,0.) # node , FX FY MZ -- superstructure-weight\n",
161 | "\n",
162 | "ops.wipeAnalysis() # adding this to clear Analysis module \n",
163 | "ops.constraints('Plain') # how it handles boundary conditions\n",
164 | "ops.numberer('Plain') # renumber dofs to minimize band-width (optimization), if you want to\n",
165 | "ops.system('BandGeneral') # how to store and solve the system of equations in the analysis\n",
166 | "ops.test('NormDispIncr',1.0e-8,6) # determine if convergence has been achieved at the end of an iteration step\n",
167 | "ops.algorithm('Newton') # use Newtons solution algorithm: updates tangent stiffness at every iteration\n",
168 | "ops.integrator('LoadControl',0.1) # determine the next time step for an analysis, apply gravity in 10 steps\n",
169 | "ops.analysis('Static') # define type of analysis static or transient\n",
170 | "ops.analyze(10) # perform gravity analysis\n",
171 | "ops.loadConst('-time',0.0) # hold gravity constant and restart time\n",
172 | "\n",
173 | "# define LATERAL load -------------------------------------------------------------\n",
174 | "# Lateral load pattern\n",
175 | "ops.timeSeries('Linear',2) # timeSeries Linear 2;\n",
176 | "# define Load Pattern\n",
177 | "ops.pattern('Plain',2,2) # \n",
178 | "ops.load(2,2000.,0.0,0.0) # node , FX FY MZ -- representative lateral load at top node\n",
179 | "\n",
180 | "\n",
181 | "# pushover: diplacement controlled static analysis\n",
182 | "ops.integrator('DisplacementControl',2,1,0.1) # switch to displacement control, for node 11, dof 1, 0.1 increment\n",
183 | "ops.analyze(1000) # apply 100 steps of pushover analysis to a displacement of 10\n",
184 | "\n",
185 | "print('Done!')\n"
186 | ]
187 | },
188 | {
189 | "cell_type": "code",
190 | "execution_count": 2,
191 | "metadata": {},
192 | "outputs": [
193 | {
194 | "data": {
195 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEICAYAAACktLTqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAARh0lEQVR4nO3df4xdZ33n8fcnNoRaJSWux1k3djwp9R84qQrUSul2RVFTIA2IRFBap9PiNNm1KkW7oXRVJeuVqko7Km2XbbSrompo0JriElkLhQillNRtqKg2ZCeQ0ObXxhD/Skw8lK4aEsnF4bt/zDG9ce7M3PlxfceP3y/p6pzzPM859/voSh8fn3vunFQVkqS2XDDqAiRJK89wl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuLUKS8SSVZO0AY29M8sWzUZd0JsNdTUtyKMk/J9lwRvtDXUiPj6YyabgMd50PngJuOL2R5EeB7xtdOdLwGe46H/wJ8L6e7V3Ax05vJPmBJB9LMpPkcJL/nOSCrm9Nkv+a5JtJvg68o/fA3b53Jjme5Okk/yXJmrMxKWk+hrvOB/cDFyV5XRe8vwh8vKf/fwA/APww8NPM/kPwq13fvwPeCbwB2AH8/BnH3gucAn6kG/M24N8OZxrS4Ax3nS9On72/FXgceLprPx32t1fVc1V1CPgQ8Ctd/y8Ad1TV0ar6FvA7pw+Y5BLg54D3V9XzVXUC+ANg51mYjzSvBb/xlxrxJ8DfAJfTc0kG2AC8Ejjc03YYuLRb/yHg6Bl9p20FXgEcT3K67YIzxksjYbjrvFBVh5M8BVwL3NzT9U3gO8wG9aNd22X8y5n9cWBLz/jLetaPAieBDVV1ahh1S0vlZRmdT24Gfqaqnu9pexHYD0wmeXWSrcAH+Jdr8vuB/5Bkc5KLgdtO71hVx4HPAx9KclGSC5K8NslPn5XZSPMw3HXeqKqvVdV0n65/DzwPfB34IvCnwEe7vo8AfwE8DHwZ+NQZ+76P2cs6jwL/CPwvYNOKFy8tUnxYhyS1xzN3SWqQ4S5JDTLcJalBhrskNWhV3Oe+YcOGGh8fH3UZknROefDBB79ZVWP9+lZFuI+PjzM93e8ONWkVOHoU3vc++MY34IILYPduuPXWUVclkeTwXH2rItylVW3tWvjQh+CNb4TnnoMf/3F461th+/ZRVybNyWvu0kI2bZoNdoBXvxpe9zp4+un595FGzHCXFuPQIfjKV+AnfmLUlUjzMtylQX372/Ce98Add8BFF426Gmlehrs0iO98ZzbYJybg3e8edTXSggx3aQ779u1jfHycCxI+efHFPJ7ABz4w6rKkgRjuUh/79u1j9+7dHD58mH8NvOf55zn1+c/zra1b4fWvh3vuGXWJ0ry8FVLqY8+ePbzwwgsA/C0QgCq2Jhx66KFRliYNxDN3qY8jR44sql1abQx3qY/LLrtsUe3SamO4S31MTk6ybt26l7StW7eOycnJEVUkLY7hLvUxMTHB1NQUF154IQBbt25lamqKiYmJEVcmDcYvVKU5TExM8JGPfASA++67b7TFSIvkmbskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0aONyTrEnylSSf7bbXJ7k3yZPd8uKesbcnOZjkiSRvH0bhkqS5LebM/VbgsZ7t24ADVbUNONBtk2Q7sBO4ArgG+HCSNStTriRpEAOFe5LNwDuAP+5pvg7Y263vBa7vab+rqk5W1VPAQeCqlSlXkjSIQc/c7wB+E/huT9slVXUcoFtu7NovBY72jDvWtb1Ekt1JppNMz8zMLLpwSdLcFgz3JO8ETlTVgwMeM33a6mUNVVNVtaOqdoyNjQ14aEnSIAb5w2E/BbwrybXAq4CLknwceDbJpqo6nmQTcKIbfwzY0rP/ZuCZlSxakjS/Bc/cq+r2qtpcVePMflH6V1X1y8DdwK5u2C7gM9363cDOJBcmuRzYBjyw4pVLkua0nD/5+0Fgf5KbgSPAewGq6pEk+4FHgVPALVX14rIrlSQNbFHhXlX3Afd16/8AXD3HuEnAR9ZI0oj4C1VJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNWjBcE/yqiQPJHk4ySNJfrtrX5/k3iRPdsuLe/a5PcnBJE8kefswJyBJerlBztxPAj9TVT8GvB64JsmbgNuAA1W1DTjQbZNkO7ATuAK4BvhwkjXDKF6S1N+C4V6zvt1tvqJ7FXAdsLdr3wtc361fB9xVVSer6ingIHDVilYtSZrXQNfck6xJ8hBwAri3qr4EXFJVxwG65cZu+KXA0Z7dj3VtkqSzZKBwr6oXq+r1wGbgqiRXzjM8/Q7xskHJ7iTTSaZnZmYGq1aSNJBF3S1TVf8PuI/Za+nPJtkE0C1PdMOOAVt6dtsMPNPnWFNVtaOqdoyNjS2hdEnSXAa5W2YsyWu69e8DfhZ4HLgb2NUN2wV8plu/G9iZ5MIklwPbgAdWunBJ0tzWDjBmE7C3u+PlAmB/VX02yf8G9ie5GTgCvBegqh5Jsh94FDgF3FJVLw6nfElSPwuGe1V9FXhDn/Z/AK6eY59JYHLZ1UmSlsRfqEpSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEsDuOkm2LgRrrxy1JVIgzHcpQHceCN87nOjrkIanOEuDeDNb4b160ddhTQ4w12SGmS4S1KDDHdJapDhLkkNMtylAdxwA/zkT8ITT8DmzXDnnaOuSJrf2lEXIJ0LPvGJUVcgLY5n7pLUIMNdkhpkuEtSgwx3SWrQguGeZEuSv07yWJJHktzata9Pcm+SJ7vlxT373J7kYJInkrx9mBOQJL3cIGfup4DfqKrXAW8CbkmyHbgNOFBV24AD3TZd307gCuAa4MNJ1gyjeElSfwuGe1Udr6ovd+vPAY8BlwLXAXu7YXuB67v164C7qupkVT0FHASuWunCJUlzW9Q19yTjwBuALwGXVNVxmP0HANjYDbsUONqz27Gu7cxj7U4ynWR6ZmZm8ZVLkuY0cLgn+X7gk8D7q+qf5hvap61e1lA1VVU7qmrH2NjYoGVIkgYwULgneQWzwb6vqj7VNT+bZFPXvwk40bUfA7b07L4ZeGZlypUkDWKQu2UC3Ak8VlX/rafrbmBXt74L+ExP+84kFya5HNgGPLByJUuSFjLI35b5KeBXgL9L8lDX9p+ADwL7k9wMHAHeC1BVjyTZDzzK7J02t1TViyteuSRpTguGe1V9kf7X0QGunmOfSWByGXVJkpbBX6hKUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1aMFwT/LRJCeS/H1P2/ok9yZ5slte3NN3e5KDSZ5I8vZhFS5JmtsgZ+7/E7jmjLbbgANVtQ040G2TZDuwE7ii2+fDSdasWLWSpIEsGO5V9TfAt85ovg7Y263vBa7vab+rqk5W1VPAQeCqFapVkjSgpV5zv6SqjgN0y41d+6XA0Z5xx7q2l0myO8l0kumZmZklliFJ6melv1BNn7bqN7CqpqpqR1XtGBsbW+EyJOn8ttRwfzbJJoBueaJrPwZs6Rm3GXhm6eVJkpZiqeF+N7CrW98FfKanfWeSC5NcDmwDHlheiZKkxVq70IAknwDeAmxIcgz4LeCDwP4kNwNHgPcCVNUjSfYDjwKngFuq6sUh1S5JmsOC4V5VN8zRdfUc4yeByeUUJUlaHn+hKkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3aRA33QQbN8KVV466Emkghrs0iBtvhM99btRVSAMz3KVBvPnNsH79qKuQBma4S1KDDHdJapDhLkkNGlq4J7kmyRNJDia5bVjvIw3Lvn37uP/++/nCF77A+Pg4n/70p0ddkjSwoYR7kjXAHwI/B2wHbkiyfRjvJQ3Dvn372L17NydPngTgdw4f5k2//ut89/HHYfNmuPPOEVcozW/tkI57FXCwqr4OkOQu4Drg0SG9n7Si9uzZwwsvvPC97V/qlls3b+bQoUMjqUlajGFdlrkUONqzfaxr+54ku5NMJ5memZkZUhnS0hw5cmRR7dJqM6xwT5+2eslG1VRV7aiqHWNjY0MqQ1qayy67bFHt0mozrHA/Bmzp2d4MPDOk95JW3OTkJOvWrXtJ27p165icnBxRRdLiDCvc/w+wLcnlSV4J7ATuHtJ7SStuYmKCqakptm7dShK2bt3K1NQUExMToy5NGkiqauFRSzlwci1wB7AG+GhVzXnKs2PHjpqenh5KHZLUqiQPVtWOfn3DuluGqroHuGdYx5ckzc1fqEpSgwx3SWqQ4S5JDTLcJalBQ7tbZlFFJDPA4VHXsQQbgG+OuoizzDmfH863OZ+r891aVX1/Bboqwv1clWR6rtuQWuWczw/n25xbnK+XZSSpQYa7JDXIcF+eqVEXMALO+fxwvs25ufl6zV2SGuSZuyQ1yHCXpAYZ7gtIsj7JvUme7JYXzzFu3geCJ/mPSSrJhuFXvTzLnXOS30/yeJKvJvmzJK85e9UPboDPLEn+e9f/1SRvHHTf1Wqpc06yJclfJ3ksySNJbj371S/Ncj7nrn9Nkq8k+ezZq3oFVJWveV7A7wG3deu3Ab/bZ8wa4GvADwOvBB4Gtvf0bwH+gtkfam0Y9ZyGPWfgbcDabv13++0/6tdCn1k35lrgz5l9stibgC8Nuu9qfC1zzpuAN3brrwb+b+tz7un/APCnwGdHPZ/FvDxzX9h1wN5ufS9wfZ8x33sgeFX9M3D6geCn/QHwm5zxqMFVbFlzrqrPV9Wpbtz9zD6Ja7VZ6DOj2/5YzbofeE2STQPuuxotec5VdbyqvgxQVc8Bj3HGc5FXqeV8ziTZDLwD+OOzWfRKMNwXdklVHQfolhv7jJnzgeBJ3gU8XVUPD7vQFbSsOZ/hJmbPilabQeqfa8ygc19tljPn70kyDrwB+NKKV7jyljvnO5g9MfvusAoclqE9rONckuQvgX/Vp2vPoIfo01ZJ1nXHeNtSaxuWYc35jPfYA5wC9i2uurNiwfrnGTPIvqvRcuY825l8P/BJ4P1V9U8rWNuwLHnOSd4JnKiqB5O8ZcUrGzLDHaiqn52rL8mzp/9b2v1X7USfYXM9EPy1wOXAw0lOt385yVVV9Y0Vm8ASDHHOp4+xC3gncHV1Fy5XmUEe4j7XmFcOsO9qtJw5k+QVzAb7vqr61BDrXEnLmfPPA+/qHhn6KuCiJB+vql8eYr0rZ9QX/Vf7C/h9Xvrl4u/1GbMW+DqzQX76S5sr+ow7xLnxheqy5gxcAzwKjI16LvPMccHPjNlrrb1ftD2wmM97tb2WOecAHwPuGPU8ztaczxjzFs6xL1RHXsBqfwE/CBwAnuyW67v2HwLu6Rl3LbN3EHwN2DPHsc6VcF/WnIGDzF7DfKh7/dGo5zTHPF9WP/BrwK916wH+sOv/O2DHYj7v1fha6pyBf8Ps5Yyv9nyu1456PsP+nHuOcc6Fu39+QJIa5N0yktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ16P8DfIo8+L/ri9UAAAAASUVORK5CYII=\n",
196 | "text/plain": [
197 | ""
198 | ]
199 | },
200 | "metadata": {
201 | "needs_background": "light"
202 | },
203 | "output_type": "display_data"
204 | }
205 | ],
206 | "source": [
207 | "eSEESminiPy.drawModel()\n"
208 | ]
209 | },
210 | {
211 | "cell_type": "code",
212 | "execution_count": 3,
213 | "metadata": {},
214 | "outputs": [
215 | {
216 | "data": {
217 | "image/png": "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\n",
218 | "text/plain": [
219 | ""
220 | ]
221 | },
222 | "metadata": {
223 | "needs_background": "light"
224 | },
225 | "output_type": "display_data"
226 | }
227 | ],
228 | "source": [
229 | "# plot deformed shape at end of analysis (it may have returned to rest)\n",
230 | "# amplify the deformtions by 5\n",
231 | "eSEESminiPy.drawDeformedShape(5)"
232 | ]
233 | },
234 | {
235 | "cell_type": "code",
236 | "execution_count": 4,
237 | "metadata": {},
238 | "outputs": [
239 | {
240 | "data": {
241 | "image/png": "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\n",
242 | "text/plain": [
243 | ""
244 | ]
245 | },
246 | "metadata": {
247 | "needs_background": "light"
248 | },
249 | "output_type": "display_data"
250 | },
251 | {
252 | "name": "stdout",
253 | "output_type": "stream",
254 | "text": [
255 | "End of Run: pyEx1a.Canti2D.Push.tcl.py\n"
256 | ]
257 | }
258 | ],
259 | "source": [
260 | "ops.wipe() # the wipe command here closes all recorder files\n",
261 | "plt.close('all')\n",
262 | "fname3 = 'Data/DFreeEx1aPush.out'\n",
263 | "dataDFree = numpy.loadtxt(fname3)\n",
264 | "plt.subplot(211)\n",
265 | "plt.title('Ex1a.Canti2D.Push.tcl')\n",
266 | "plt.grid(True)\n",
267 | "plt.plot(dataDFree[:,1])\n",
268 | "plt.xlabel('Step Number')\n",
269 | "plt.ylabel('Free-Node Displacement')\n",
270 | "plt.subplot(212)\n",
271 | "plt.grid(True)\n",
272 | "plt.plot(dataDFree[:,1],dataDFree[:,0])\n",
273 | "plt.xlabel('Free-Node Disp.')\n",
274 | "plt.ylabel('Pseudo-Time (~Force)')\n",
275 | "plt.show()\n",
276 | "print('End of Run: pyEx1a.Canti2D.Push.tcl.py')\n"
277 | ]
278 | },
279 | {
280 | "cell_type": "code",
281 | "execution_count": null,
282 | "metadata": {},
283 | "outputs": [],
284 | "source": []
285 | }
286 | ],
287 | "metadata": {
288 | "kernelspec": {
289 | "display_name": "Python 3",
290 | "language": "python",
291 | "name": "python3"
292 | },
293 | "language_info": {
294 | "codemirror_mode": {
295 | "name": "ipython",
296 | "version": 3
297 | },
298 | "file_extension": ".py",
299 | "mimetype": "text/x-python",
300 | "name": "python",
301 | "nbconvert_exporter": "python",
302 | "pygments_lexer": "ipython3",
303 | "version": "3.8.3"
304 | }
305 | },
306 | "nbformat": 4,
307 | "nbformat_minor": 4
308 | }
309 |
--------------------------------------------------------------------------------
/BraineryBytes_OpenSees_Examples_Manual_Example_1b_Elastic_Portal_Frame_EQgroundMotion.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "
OpenSees Examples Manual Examples for OpenSeesPy
\n",
8 | "
OpenSees Example 1b. Elastic Portal Frame -- Earthquake Ground Motion
\n",
9 | "
\n",
10 | "\n",
11 | "You can find the original Examples: \n",
12 | "https://opensees.berkeley.edu/wiki/index.php/Examples_Manual \n",
13 | "Original Examples by By Silvia Mazzoni & Frank McKenna, 2006, in Tcl \n",
14 | "Converted to OpenSeesPy by SilviaMazzoni, 2020 \n",
15 | "
\n",
16 | "\n",
17 | "
Simulation Process
\n",
18 | "\n",
19 | "Each example script does the following:\n",
20 | "
define the input motion and all associated parameters, such as scaling and input type
\n",
45 | "
define analysis duration and time increment
\n",
46 | "
define damping
\n",
47 | "
analyze
\n",
48 | "
\n",
49 | " \n",
50 | "Introductory Examples\n",
51 | "The objective of Example 1a and Example 1b is to give an overview of input-file format in OpenSees using simple scripts.\n",
52 | "These scripts do not take advantage of the Tcl scripting capabilities shown in the later examples. However, they do provide starting a place where the input file is similar to that of more familiar Finite-Element Analysis software. Subsequent examples should be used as the basis for user input files.\n",
53 | " "
54 | ]
55 | },
56 | {
57 | "cell_type": "markdown",
58 | "metadata": {},
59 | "source": [
60 | "
\n",
62 | "\n",
63 | " Objectives of Example 1b \n",
64 | " - Two element types \n",
65 | " - Distributed element loads \n",
66 | " \n",
67 | "\n",
68 | "\n",
69 | " "
70 | ]
71 | },
72 | {
73 | "cell_type": "code",
74 | "execution_count": 1,
75 | "metadata": {},
76 | "outputs": [
77 | {
78 | "name": "stdout",
79 | "output_type": "stream",
80 | "text": [
81 | "Done!\n"
82 | ]
83 | }
84 | ],
85 | "source": [
86 | "############################################################\n",
87 | "# EXAMPLE: \n",
88 | "# pyEx1b.Portal2D.EQ.tcl.py\n",
89 | "# for OpenSeesPy\n",
90 | "# --------------------------------------------------------#\n",
91 | "# by: Silvia Mazzoni, 2020\n",
92 | "# silviamazzoni@yahoo.com\n",
93 | "############################################################\n",
94 | "\n",
95 | "# configure Python workspace\n",
96 | "import openseespy.opensees as ops\n",
97 | "import eSEESminiPy\n",
98 | "import os\n",
99 | "import math\n",
100 | "import numpy as numpy\n",
101 | "import matplotlib.pyplot as plt\n",
102 | "ops.wipe()\n",
103 | "# --------------------------------------------------------------------------------------------------\n",
104 | "# Example 1. portal frame in 2D\n",
105 | "# dynamic earthquake analysis of Portal Frame, with gravity.\n",
106 | "# all units are in kip, inch, second\n",
107 | "# elasticBeamColumn ELEMENT\n",
108 | "# Silvia Mazzoni and Frank McKenna, 2006\n",
109 | "#\n",
110 | "# ^Y\n",
111 | "# or\n",
112 | "# 3_________(3)________4 __\n",
113 | "# or | |\n",
114 | "# or | |\n",
115 | "# or | |\n",
116 | "# (1) (2) LCol\n",
117 | "# or | |\n",
118 | "# or | |\n",
119 | "# or | |\n",
120 | "# =1= =2= _or_ -------->X\n",
121 | "# or----------LBeam------------|\n",
122 | "#\n",
123 | "\n",
124 | "# SET UP ----------------------------------------------------------------------------\n",
125 | "ops.wipe() # clear opensees model\n",
126 | "ops.model('basic','-ndm',2,'-ndf',3) # 2 dimensions, 3 dof per node\n",
127 | "if not os.path.exists('Data'):\n",
128 | " os.mkdir('Data')\n",
129 | "\n",
130 | "\n",
131 | "# define GEOMETRY -------------------------------------------------------------\n",
132 | "# nodal coordinates:\n",
133 | "ops.node(1,0,0) # node , X Y\n",
134 | "ops.node(2,504,0)\n",
135 | "ops.node(3,0,432)\n",
136 | "ops.node(4,504,432)\n",
137 | "\n",
138 | "# Single point constraints -- Boundary Conditions\n",
139 | "ops.fix(1,1,1,1) # node DX DY RZ\n",
140 | "ops.fix(2,1,1,1) # node DX DY RZ\n",
141 | "ops.fix(3,0,0,0)\n",
142 | "ops.fix(4,0,0,0)\n",
143 | "\n",
144 | "# nodal masses:\n",
145 | "ops.mass(3,5.18,0.,0.) # node , Mx My Mz, Mass=Weight/g.\n",
146 | "ops.mass(4,5.18,0.,0.)\n",
147 | "\n",
148 | "# Define ELEMENTS -------------------------------------------------------------\n",
149 | "# define geometric transformation: performs a linear geometric transformation of beam stiffness and resisting force from the basic system to the global-coordinate system\n",
150 | "ops.geomTransf('Linear',1) # associate a tag to transformation\n",
151 | "\n",
152 | "# connectivity: (make A very large, 10e6 times its actual value)\n",
153 | "ops.element('elasticBeamColumn',1,1,3,3600000000,4227,1080000,1) # element elasticBeamColumn eleTag iNode jNode A E Iz transfTag\n",
154 | "ops.element('elasticBeamColumn',2,2,4,3600000000,4227,1080000,1)\n",
155 | "ops.element('elasticBeamColumn',3,3,4,5760000000,4227,4423680,1)\n",
156 | "\n",
157 | "# Define RECORDERS -------------------------------------------------------------\n",
158 | "ops.recorder('Node','-file','Data/DFreeEx1bEQ.out','-time','-node',3,4,'-dof',1,2,3,'disp') # displacements of free nodes\n",
159 | "ops.recorder('Node','-file','Data/DBaseEx1bEQ.out','-time','-node',1,2,'-dof',1,2,3,'disp') # displacements of support nodes\n",
160 | "ops.recorder('Node','-file','Data/RBaseEx1bEQ.out','-time','-node',1,2,'-dof',1,2,3,'reaction') # support reaction\n",
161 | "ops.recorder('Element','-file','Data/FColEx1bEQ.out','-time','-ele',1,2,'globalForce') # element forces -- column\n",
162 | "ops.recorder('Element','-file','Data/FBeamEx1bEQ.out','-time','-ele',3,'globalForce') # element forces -- beam\n",
163 | "\n",
164 | "# define GRAVITY -------------------------------------------------------------\n",
165 | "ops.timeSeries('Linear',1) # timeSeries Linear 1;\n",
166 | "# define Load Pattern\n",
167 | "ops.pattern('Plain',1,1) # \n",
168 | "ops.eleLoad('-ele',3,'-type','-beamUniform',-7.94) # distributed superstructure-weight on beam\n",
169 | "\n",
170 | "ops.wipeAnalysis() # adding this to clear Analysis module \n",
171 | "ops.constraints('Plain') # how it handles boundary conditions\n",
172 | "ops.numberer('Plain') # renumber dofs to minimize band-width (optimization), if you want to\n",
173 | "ops.system('BandGeneral') # how to store and solve the system of equations in the analysis\n",
174 | "ops.test('NormDispIncr',1.0e-8,6) # determine if convergence has been achieved at the end of an iteration step\n",
175 | "ops.algorithm('Newton') # use Newtons solution algorithm: updates tangent stiffness at every iteration\n",
176 | "ops.integrator('LoadControl',0.1) # determine the next time step for an analysis, apply gravity in 10 steps\n",
177 | "ops.analysis('Static') # define type of analysis static or transient\n",
178 | "ops.analyze(10) # perform gravity analysis\n",
179 | "ops.loadConst('-time',0.0) # hold gravity constant and restart time\n",
180 | "\n",
181 | "# DYNAMIC ground-motion analysis -------------------------------------------------------------\n",
182 | "# create load pattern\n",
183 | "accelSeries = 900\n",
184 | "ops.timeSeries('Path',accelSeries,'-dt',0.01,'-filePath','BM68elc.acc','-factor',1) # define acceleration vector from file (dt=0.01 is associated with the input file gm)\n",
185 | "ops.pattern('UniformExcitation',2,1,'-accel',accelSeries) # define where and how (pattern tag, dof) acceleration is applied\n",
186 | "ops.rayleigh(0.,0.,0.,2*0.02/math.pow(ops.eigen('-fullGenLapack',1)[0],0.5)) # set damping based on first eigen mode\n",
187 | "\n",
188 | "# create the analysis\n",
189 | "ops.wipeAnalysis() # clear previously-define analysis parameters\n",
190 | "ops.wipeAnalysis() # adding this to clear Analysis module \n",
191 | "ops.constraints('Plain') # how it handles boundary conditions\n",
192 | "ops.numberer('Plain') # renumber dofs to minimize band-width (optimization), if you want to\n",
193 | "ops.system('BandGeneral') # how to store and solve the system of equations in the analysis\n",
194 | "ops.test('NormDispIncr',1.0e-8,10) # determine if convergence has been achieved at the end of an iteration step\n",
195 | "ops.algorithm('Newton') # use Newtons solution algorithm: updates tangent stiffness at every iteration\n",
196 | "ops.integrator('Newmark',0.5,0.25) # determine the next time step for an analysis\n",
197 | "ops.analysis('Transient') # define type of analysis: time-dependent\n",
198 | "ops.analyze(1000,0.02) # apply 1000 0.02-sec time steps in analysis\n",
199 | "\n",
200 | "\n",
201 | "print('Done!')\n",
202 | "\n",
203 | "\n",
204 | "\n",
205 | "\n"
206 | ]
207 | },
208 | {
209 | "cell_type": "code",
210 | "execution_count": 2,
211 | "metadata": {},
212 | "outputs": [
213 | {
214 | "data": {
215 | "image/png": "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\n",
216 | "text/plain": [
217 | ""
218 | ]
219 | },
220 | "metadata": {
221 | "needs_background": "light"
222 | },
223 | "output_type": "display_data"
224 | }
225 | ],
226 | "source": [
227 | "eSEESminiPy.drawModel()"
228 | ]
229 | },
230 | {
231 | "cell_type": "code",
232 | "execution_count": 3,
233 | "metadata": {},
234 | "outputs": [
235 | {
236 | "data": {
237 | "image/png": "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\n",
238 | "text/plain": [
239 | ""
240 | ]
241 | },
242 | "metadata": {
243 | "needs_background": "light"
244 | },
245 | "output_type": "display_data"
246 | }
247 | ],
248 | "source": [
249 | "# plot deformed shape at end of analysis (it may have returned to rest)\n",
250 | "# amplify the deformtions by 5\n",
251 | "eSEESminiPy.drawDeformedShape(5)"
252 | ]
253 | },
254 | {
255 | "cell_type": "code",
256 | "execution_count": 4,
257 | "metadata": {},
258 | "outputs": [
259 | {
260 | "name": "stdout",
261 | "output_type": "stream",
262 | "text": [
263 | "End of Run: pyEx1b.Portal2D.EQ.tcl.py\n"
264 | ]
265 | },
266 | {
267 | "data": {
268 | "image/png": "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\n",
269 | "text/plain": [
270 | ""
271 | ]
272 | },
273 | "metadata": {
274 | "needs_background": "light"
275 | },
276 | "output_type": "display_data"
277 | }
278 | ],
279 | "source": [
280 | "ops.wipe() # the wipe command here closes all recorder files\n",
281 | "plt.close('all')\n",
282 | "fname3 = 'Data/DFreeEx1bEQ.out'\n",
283 | "dataDFree = numpy.loadtxt(fname3)\n",
284 | "plt.plot(dataDFree[:,0],dataDFree[:,1])\n",
285 | "plt.xlabel('Pseudo-Time (~Force)')\n",
286 | "plt.ylabel('Free-Node Disp.')\n",
287 | "plt.title('Ex1b.Portal2D.EQ.tcl')\n",
288 | "plt.grid(True)\n",
289 | "print('End of Run: pyEx1b.Portal2D.EQ.tcl.py')"
290 | ]
291 | }
292 | ],
293 | "metadata": {
294 | "kernelspec": {
295 | "display_name": "Python 3",
296 | "language": "python",
297 | "name": "python3"
298 | },
299 | "language_info": {
300 | "codemirror_mode": {
301 | "name": "ipython",
302 | "version": 3
303 | },
304 | "file_extension": ".py",
305 | "mimetype": "text/x-python",
306 | "name": "python",
307 | "nbconvert_exporter": "python",
308 | "pygments_lexer": "ipython3",
309 | "version": "3.8.3"
310 | }
311 | },
312 | "nbformat": 4,
313 | "nbformat_minor": 4
314 | }
315 |
--------------------------------------------------------------------------------
/BraineryBytes_OpenSees_Examples_Manual_Example_1b_Elastic_Portal_Frame_Pushover.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "
OpenSees Examples Manual Examples for OpenSeesPy
\n",
8 | "
OpenSees Example 1b. Elastic Portal Frame -- Static Pushover
\n",
9 | "
\n",
10 | "\n",
11 | "You can find the original Examples: \n",
12 | "https://opensees.berkeley.edu/wiki/index.php/Examples_Manual \n",
13 | "Original Examples by By Silvia Mazzoni & Frank McKenna, 2006, in Tcl \n",
14 | "Converted to OpenSeesPy by SilviaMazzoni, 2020 \n",
15 | "
\n",
16 | "\n",
17 | "
Simulation Process
\n",
18 | "\n",
19 | "Each example script does the following:\n",
20 | "
define the input motion and all associated parameters, such as scaling and input type
\n",
45 | "
define analysis duration and time increment
\n",
46 | "
define damping
\n",
47 | "
analyze
\n",
48 | "
\n",
49 | " \n",
50 | "Introductory Examples\n",
51 | "The objective of Example 1a and Example 1b is to give an overview of input-file format in OpenSees using simple scripts.\n",
52 | "These scripts do not take advantage of the Tcl scripting capabilities shown in the later examples. However, they do provide starting a place where the input file is similar to that of more familiar Finite-Element Analysis software. Subsequent examples should be used as the basis for user input files.\n"
53 | ]
54 | },
55 | {
56 | "cell_type": "markdown",
57 | "metadata": {},
58 | "source": [
59 | "
![](\"https://opensees.berkeley.edu/wiki/images/e/ec/Example1a_Push.GIF\")
\n"
68 | ]
69 | },
70 | {
71 | "cell_type": "code",
72 | "execution_count": 1,
73 | "metadata": {},
74 | "outputs": [
75 | {
76 | "name": "stdout",
77 | "output_type": "stream",
78 | "text": [
79 | "Done!\n"
80 | ]
81 | }
82 | ],
83 | "source": [
84 | "############################################################\n",
85 | "# EXAMPLE: \n",
86 | "# pyEx1a.Canti2D.Push.tcl.py\n",
87 | "# for OpenSeesPy\n",
88 | "# --------------------------------------------------------#\n",
89 | "# by: Silvia Mazzoni, 2020\n",
90 | "# silviamazzoni@yahoo.com\n",
91 | "############################################################\n",
92 | "# This file was obtained from a conversion of the updated Tcl script\n",
93 | "############################################################\n",
94 | "\n",
95 | "# configure Python workspace\n",
96 | "import openseespy.opensees as ops\n",
97 | "import eSEESminiPy\n",
98 | "import os\n",
99 | "import math\n",
100 | "import numpy as numpy\n",
101 | "import matplotlib.pyplot as plt\n",
102 | "ops.wipe()\n",
103 | "# --------------------------------------------------------------------------------------------------\n",
104 | "# Example 1. cantilever 2D\n",
105 | "# static pushover analysis with gravity.\n",
106 | "# all units are in kip, inch, second\n",
107 | "# elasticBeamColumn ELEMENT\n",
108 | "# Silvia Mazzoni and Frank McKenna, 2006\n",
109 | "#\n",
110 | "# ^Y\n",
111 | "# or\n",
112 | "# 2 __\n",
113 | "# or |\n",
114 | "# or |\n",
115 | "# or |\n",
116 | "# (1) 36'\n",
117 | "# or |\n",
118 | "# or |\n",
119 | "# or |\n",
120 | "# =1= ---- -------->X\n",
121 | "#\n",
122 | "\n",
123 | "# SET UP ----------------------------------------------------------------------------\n",
124 | "ops.wipe() # clear opensees model\n",
125 | "ops.model('basic','-ndm',2,'-ndf',3) # 2 dimensions, 3 dof per node\n",
126 | "if not os.path.exists('Data'):\n",
127 | " os.mkdir('Data')\n",
128 | "\n",
129 | "# define GEOMETRY -------------------------------------------------------------\n",
130 | "# nodal coordinates:\n",
131 | "ops.node(1,0,0) # node , X Y\n",
132 | "ops.node(2,0,432)\n",
133 | "\n",
134 | "# Single point constraints -- Boundary Conditions\n",
135 | "ops.fix(1,1,1,1) # node DX DY RZ\n",
136 | "\n",
137 | "# nodal masses:\n",
138 | "ops.mass(2,5.18,0.,0.) # node , Mx My Mz, Mass=Weight/g.\n",
139 | "\n",
140 | "# Define ELEMENTS -------------------------------------------------------------\n",
141 | "# define geometric transformation: performs a linear geometric transformation of beam stiffness\n",
142 | "# and resisting force from the basic system to the global-coordinate system\n",
143 | "ops.geomTransf('Linear',1) # associate a tag to transformation\n",
144 | "\n",
145 | "# connectivity: (make A very large, 10e6 times its actual value)\n",
146 | "# element elasticBeamColumn eleTag iNode jNode A E Iz transfTag\n",
147 | "ops.element('elasticBeamColumn',1,1,2,3600000000,4227,1080000,1) # element elasticBeamColumn 1 1 2 3600000000 4227 1080000 1;\n",
148 | "\n",
149 | "# Define RECORDERS -------------------------------------------------------------\n",
150 | "ops.recorder('Node','-file','Data/DFreeEx1aPush.out','-time','-node',2,'-dof',1,2,3,'disp') # displacements of free nodes\n",
151 | "ops.recorder('Node','-file','Data/DBaseEx1aPush.out','-time','-node',1,'-dof',1,2,3,'disp') # displacements of support nodes\n",
152 | "ops.recorder('Node','-file','Data/RBaseEx1aPush.out','-time','-node',1,'-dof',1,2,3,'reaction') # support reaction\n",
153 | "ops.recorder('Element','-file','Data/FColEx1aPush.out','-time','-ele',1,'globalForce') # element forces -- column\n",
154 | "ops.recorder('Element','-file','Data/DColEx1aPush.out','-time','-ele',1,'deformation') # element deformations -- column\n",
155 | "\n",
156 | "# define GRAVITY -------------------------------------------------------------\n",
157 | "ops.timeSeries('Linear',1) # timeSeries Linear 1;\n",
158 | "# define Load Pattern\n",
159 | "ops.pattern('Plain',1,1) # \n",
160 | "ops.load(2,0.,-2000.,0.) # node , FX FY MZ -- superstructure-weight\n",
161 | "\n",
162 | "ops.wipeAnalysis() # adding this to clear Analysis module \n",
163 | "ops.constraints('Plain') # how it handles boundary conditions\n",
164 | "ops.numberer('Plain') # renumber dofs to minimize band-width (optimization), if you want to\n",
165 | "ops.system('BandGeneral') # how to store and solve the system of equations in the analysis\n",
166 | "ops.test('NormDispIncr',1.0e-8,6) # determine if convergence has been achieved at the end of an iteration step\n",
167 | "ops.algorithm('Newton') # use Newtons solution algorithm: updates tangent stiffness at every iteration\n",
168 | "ops.integrator('LoadControl',0.1) # determine the next time step for an analysis, apply gravity in 10 steps\n",
169 | "ops.analysis('Static') # define type of analysis static or transient\n",
170 | "ops.analyze(10) # perform gravity analysis\n",
171 | "ops.loadConst('-time',0.0) # hold gravity constant and restart time\n",
172 | "\n",
173 | "# define LATERAL load -------------------------------------------------------------\n",
174 | "# Lateral load pattern\n",
175 | "ops.timeSeries('Linear',2) # timeSeries Linear 2;\n",
176 | "# define Load Pattern\n",
177 | "ops.pattern('Plain',2,2) # \n",
178 | "ops.load(2,2000.,0.0,0.0) # node , FX FY MZ -- representative lateral load at top node\n",
179 | "\n",
180 | "\n",
181 | "# pushover: diplacement controlled static analysis\n",
182 | "ops.integrator('DisplacementControl',2,1,0.1) # switch to displacement control, for node 11, dof 1, 0.1 increment\n",
183 | "ops.analyze(1000) # apply 100 steps of pushover analysis to a displacement of 10\n",
184 | "\n",
185 | "print('Done!')\n"
186 | ]
187 | },
188 | {
189 | "cell_type": "code",
190 | "execution_count": 2,
191 | "metadata": {},
192 | "outputs": [
193 | {
194 | "data": {
195 | "image/png": "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\n",
196 | "text/plain": [
197 | "![](\"https://opensees.berkeley.edu/wiki/images/d/d5/Example1b_EQ.GIF\")
\n",
68 | "\n",
69 | " "
70 | ]
71 | },
72 | {
73 | "cell_type": "code",
74 | "execution_count": 1,
75 | "metadata": {},
76 | "outputs": [
77 | {
78 | "name": "stdout",
79 | "output_type": "stream",
80 | "text": [
81 | "Done!\n"
82 | ]
83 | }
84 | ],
85 | "source": [
86 | "############################################################\n",
87 | "# EXAMPLE: \n",
88 | "# pyEx1b.Portal2D.EQ.tcl.py\n",
89 | "# for OpenSeesPy\n",
90 | "# --------------------------------------------------------#\n",
91 | "# by: Silvia Mazzoni, 2020\n",
92 | "# silviamazzoni@yahoo.com\n",
93 | "############################################################\n",
94 | "\n",
95 | "# configure Python workspace\n",
96 | "import openseespy.opensees as ops\n",
97 | "import eSEESminiPy\n",
98 | "import os\n",
99 | "import math\n",
100 | "import numpy as numpy\n",
101 | "import matplotlib.pyplot as plt\n",
102 | "ops.wipe()\n",
103 | "# --------------------------------------------------------------------------------------------------\n",
104 | "# Example 1. portal frame in 2D\n",
105 | "# dynamic earthquake analysis of Portal Frame, with gravity.\n",
106 | "# all units are in kip, inch, second\n",
107 | "# elasticBeamColumn ELEMENT\n",
108 | "# Silvia Mazzoni and Frank McKenna, 2006\n",
109 | "#\n",
110 | "# ^Y\n",
111 | "# or\n",
112 | "# 3_________(3)________4 __\n",
113 | "# or | |\n",
114 | "# or | |\n",
115 | "# or | |\n",
116 | "# (1) (2) LCol\n",
117 | "# or | |\n",
118 | "# or | |\n",
119 | "# or | |\n",
120 | "# =1= =2= _or_ -------->X\n",
121 | "# or----------LBeam------------|\n",
122 | "#\n",
123 | "\n",
124 | "# SET UP ----------------------------------------------------------------------------\n",
125 | "ops.wipe() # clear opensees model\n",
126 | "ops.model('basic','-ndm',2,'-ndf',3) # 2 dimensions, 3 dof per node\n",
127 | "if not os.path.exists('Data'):\n",
128 | " os.mkdir('Data')\n",
129 | "\n",
130 | "\n",
131 | "# define GEOMETRY -------------------------------------------------------------\n",
132 | "# nodal coordinates:\n",
133 | "ops.node(1,0,0) # node , X Y\n",
134 | "ops.node(2,504,0)\n",
135 | "ops.node(3,0,432)\n",
136 | "ops.node(4,504,432)\n",
137 | "\n",
138 | "# Single point constraints -- Boundary Conditions\n",
139 | "ops.fix(1,1,1,1) # node DX DY RZ\n",
140 | "ops.fix(2,1,1,1) # node DX DY RZ\n",
141 | "ops.fix(3,0,0,0)\n",
142 | "ops.fix(4,0,0,0)\n",
143 | "\n",
144 | "# nodal masses:\n",
145 | "ops.mass(3,5.18,0.,0.) # node , Mx My Mz, Mass=Weight/g.\n",
146 | "ops.mass(4,5.18,0.,0.)\n",
147 | "\n",
148 | "# Define ELEMENTS -------------------------------------------------------------\n",
149 | "# define geometric transformation: performs a linear geometric transformation of beam stiffness and resisting force from the basic system to the global-coordinate system\n",
150 | "ops.geomTransf('Linear',1) # associate a tag to transformation\n",
151 | "\n",
152 | "# connectivity: (make A very large, 10e6 times its actual value)\n",
153 | "ops.element('elasticBeamColumn',1,1,3,3600000000,4227,1080000,1) # element elasticBeamColumn eleTag iNode jNode A E Iz transfTag\n",
154 | "ops.element('elasticBeamColumn',2,2,4,3600000000,4227,1080000,1)\n",
155 | "ops.element('elasticBeamColumn',3,3,4,5760000000,4227,4423680,1)\n",
156 | "\n",
157 | "# Define RECORDERS -------------------------------------------------------------\n",
158 | "ops.recorder('Node','-file','Data/DFreeEx1bEQ.out','-time','-node',3,4,'-dof',1,2,3,'disp') # displacements of free nodes\n",
159 | "ops.recorder('Node','-file','Data/DBaseEx1bEQ.out','-time','-node',1,2,'-dof',1,2,3,'disp') # displacements of support nodes\n",
160 | "ops.recorder('Node','-file','Data/RBaseEx1bEQ.out','-time','-node',1,2,'-dof',1,2,3,'reaction') # support reaction\n",
161 | "ops.recorder('Element','-file','Data/FColEx1bEQ.out','-time','-ele',1,2,'globalForce') # element forces -- column\n",
162 | "ops.recorder('Element','-file','Data/FBeamEx1bEQ.out','-time','-ele',3,'globalForce') # element forces -- beam\n",
163 | "\n",
164 | "# define GRAVITY -------------------------------------------------------------\n",
165 | "ops.timeSeries('Linear',1) # timeSeries Linear 1;\n",
166 | "# define Load Pattern\n",
167 | "ops.pattern('Plain',1,1) # \n",
168 | "ops.eleLoad('-ele',3,'-type','-beamUniform',-7.94) # distributed superstructure-weight on beam\n",
169 | "\n",
170 | "ops.wipeAnalysis() # adding this to clear Analysis module \n",
171 | "ops.constraints('Plain') # how it handles boundary conditions\n",
172 | "ops.numberer('Plain') # renumber dofs to minimize band-width (optimization), if you want to\n",
173 | "ops.system('BandGeneral') # how to store and solve the system of equations in the analysis\n",
174 | "ops.test('NormDispIncr',1.0e-8,6) # determine if convergence has been achieved at the end of an iteration step\n",
175 | "ops.algorithm('Newton') # use Newtons solution algorithm: updates tangent stiffness at every iteration\n",
176 | "ops.integrator('LoadControl',0.1) # determine the next time step for an analysis, apply gravity in 10 steps\n",
177 | "ops.analysis('Static') # define type of analysis static or transient\n",
178 | "ops.analyze(10) # perform gravity analysis\n",
179 | "ops.loadConst('-time',0.0) # hold gravity constant and restart time\n",
180 | "\n",
181 | "# DYNAMIC ground-motion analysis -------------------------------------------------------------\n",
182 | "# create load pattern\n",
183 | "accelSeries = 900\n",
184 | "ops.timeSeries('Path',accelSeries,'-dt',0.01,'-filePath','BM68elc.acc','-factor',1) # define acceleration vector from file (dt=0.01 is associated with the input file gm)\n",
185 | "ops.pattern('UniformExcitation',2,1,'-accel',accelSeries) # define where and how (pattern tag, dof) acceleration is applied\n",
186 | "ops.rayleigh(0.,0.,0.,2*0.02/math.pow(ops.eigen('-fullGenLapack',1)[0],0.5)) # set damping based on first eigen mode\n",
187 | "\n",
188 | "# create the analysis\n",
189 | "ops.wipeAnalysis() # clear previously-define analysis parameters\n",
190 | "ops.wipeAnalysis() # adding this to clear Analysis module \n",
191 | "ops.constraints('Plain') # how it handles boundary conditions\n",
192 | "ops.numberer('Plain') # renumber dofs to minimize band-width (optimization), if you want to\n",
193 | "ops.system('BandGeneral') # how to store and solve the system of equations in the analysis\n",
194 | "ops.test('NormDispIncr',1.0e-8,10) # determine if convergence has been achieved at the end of an iteration step\n",
195 | "ops.algorithm('Newton') # use Newtons solution algorithm: updates tangent stiffness at every iteration\n",
196 | "ops.integrator('Newmark',0.5,0.25) # determine the next time step for an analysis\n",
197 | "ops.analysis('Transient') # define type of analysis: time-dependent\n",
198 | "ops.analyze(1000,0.02) # apply 1000 0.02-sec time steps in analysis\n",
199 | "\n",
200 | "\n",
201 | "print('Done!')\n",
202 | "\n",
203 | "\n",
204 | "\n",
205 | "\n"
206 | ]
207 | },
208 | {
209 | "cell_type": "code",
210 | "execution_count": 2,
211 | "metadata": {},
212 | "outputs": [
213 | {
214 | "data": {
215 | "image/png": "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\n",
216 | "text/plain": [
217 | "![](\"https://opensees.berkeley.edu/wiki/images/5/59/Example1b_Push.GIF\")
\n"
67 | ]
68 | },
69 | {
70 | "cell_type": "code",
71 | "execution_count": 1,
72 | "metadata": {},
73 | "outputs": [
74 | {
75 | "name": "stdout",
76 | "output_type": "stream",
77 | "text": [
78 | "Done!\n"
79 | ]
80 | }
81 | ],
82 | "source": [
83 | "############################################################\n",
84 | "# EXAMPLE: \n",
85 | "# pyEx1b.Portal2D.Push.tcl.py\n",
86 | "# for OpenSeesPy\n",
87 | "# --------------------------------------------------------#\n",
88 | "# by: Silvia Mazzoni, 2020\n",
89 | "# silviamazzoni@yahoo.com\n",
90 | "############################################################\n",
91 | "\n",
92 | "# configure Python workspace\n",
93 | "import openseespy.opensees as ops\n",
94 | "import eSEESminiPy\n",
95 | "import os\n",
96 | "import math\n",
97 | "import numpy as numpy\n",
98 | "import matplotlib.pyplot as plt\n",
99 | "ops.wipe()\n",
100 | "# --------------------------------------------------------------------------------------------------\n",
101 | "# Example 1. portal frame in 2D\n",
102 | "# static pushover analysis of Portal Frame, with gravity.\n",
103 | "# all units are in kip, inch, second\n",
104 | "# elasticBeamColumn ELEMENT\n",
105 | "# Silvia Mazzoni and Frank McKenna, 2006\n",
106 | "#\n",
107 | "# ^Y\n",
108 | "# or\n",
109 | "# 3_________(3)________4 __\n",
110 | "# or | |\n",
111 | "# or | |\n",
112 | "# or | |\n",
113 | "# (1) (2) LCol\n",
114 | "# or | |\n",
115 | "# or | |\n",
116 | "# or | |\n",
117 | "# =1= =2= _or_ -------->X\n",
118 | "# or----------LBeam------------|\n",
119 | "#\n",
120 | "\n",
121 | "# SET UP ----------------------------------------------------------------------------\n",
122 | "ops.wipe() # clear opensees model\n",
123 | "ops.model('basic','-ndm',2,'-ndf',3) # 2 dimensions, 3 dof per node\n",
124 | "if not os.path.exists('Data'):\n",
125 | " os.mkdir('Data')\n",
126 | "\n",
127 | "# define GEOMETRY -------------------------------------------------------------\n",
128 | "# nodal coordinates:\n",
129 | "ops.node(1,0,0) # node , X Y\n",
130 | "ops.node(2,504,0)\n",
131 | "ops.node(3,0,432)\n",
132 | "ops.node(4,504,432)\n",
133 | "\n",
134 | "# Single point constraints -- Boundary Conditions\n",
135 | "ops.fix(1,1,1,1) # node DX DY RZ\n",
136 | "ops.fix(2,1,1,1) # node DX DY RZ\n",
137 | "ops.fix(3,0,0,0)\n",
138 | "ops.fix(4,0,0,0)\n",
139 | "\n",
140 | "# nodal masses:\n",
141 | "ops.mass(3,5.18,0.,0.) # node , Mx My Mz, Mass=Weight/g.\n",
142 | "ops.mass(4,5.18,0.,0.)\n",
143 | "\n",
144 | "# Define ELEMENTS -------------------------------------------------------------\n",
145 | "# define geometric transformation: performs a linear geometric transformation of beam stiffness and resisting force from the basic system to the global-coordinate system\n",
146 | "ops.geomTransf('Linear',1) # associate a tag to transformation\n",
147 | "\n",
148 | "# connectivity: (make A very large, 10e6 times its actual value)\n",
149 | "ops.element('elasticBeamColumn',1,1,3,3600000000,4227,1080000,1) # element elasticBeamColumn eleTag iNode jNode A E Iz transfTag\n",
150 | "ops.element('elasticBeamColumn',2,2,4,3600000000,4227,1080000,1)\n",
151 | "ops.element('elasticBeamColumn',3,3,4,5760000000,4227,4423680,1)\n",
152 | "\n",
153 | "# Define RECORDERS -------------------------------------------------------------\n",
154 | "ops.recorder('Node','-file','Data/DFreeEx1bPush.out','-time','-node',3,4,'-dof',1,2,3,'disp') # displacements of free nodes\n",
155 | "ops.recorder('Node','-file','Data/DBaseEx1bPush.out','-time','-node',1,2,'-dof',1,2,3,'disp') # displacements of support nodes\n",
156 | "ops.recorder('Node','-file','Data/RBaseEx1bPush.out','-time','-node',1,2,'-dof',1,2,3,'reaction') # support reaction\n",
157 | "ops.recorder('Element','-file','Data/FColEx1bPush.out','-time','-ele',1,2,'globalForce') # element forces -- column\n",
158 | "ops.recorder('Element','-file','Data/FBeamEx1bPush.out','-time','-ele',3,'globalForce') # element forces -- beam\n",
159 | "\n",
160 | "# define GRAVITY -------------------------------------------------------------\n",
161 | "ops.timeSeries('Linear',1) # timeSeries Linear 1;\n",
162 | "# define Load Pattern\n",
163 | "ops.pattern('Plain',1,1) # \n",
164 | "ops.eleLoad('-ele',3,'-type','-beamUniform',-7.94) # distributed superstructure-weight on beam\n",
165 | "\n",
166 | "ops.wipeAnalysis() # adding this to clear Analysis module \n",
167 | "ops.constraints('Plain') # how it handles boundary conditions\n",
168 | "ops.numberer('Plain') # renumber dofs to minimize band-width (optimization), if you want to\n",
169 | "ops.system('BandGeneral') # how to store and solve the system of equations in the analysis\n",
170 | "ops.test('NormDispIncr',1.0e-8,6) # determine if convergence has been achieved at the end of an iteration step\n",
171 | "ops.algorithm('Newton') # use Newtons solution algorithm: updates tangent stiffness at every iteration\n",
172 | "ops.integrator('LoadControl',0.1) # determine the next time step for an analysis, apply gravity in 10 steps\n",
173 | "ops.analysis('Static') # define type of analysis static or transient\n",
174 | "ops.analyze(10) # perform gravity analysis\n",
175 | "ops.loadConst('-time',0.0) # hold gravity constant and restart time\n",
176 | "\n",
177 | "# define LATERAL load -------------------------------------------------------------\n",
178 | "# Lateral load pattern\n",
179 | "ops.timeSeries('Linear',2) # timeSeries Linear 2;\n",
180 | "# define Load Pattern\n",
181 | "ops.pattern('Plain',2,2) # \n",
182 | "ops.load(3,2000.,0.0,0.0) # node , FX FY MZ -- representative lateral load at top nodes\n",
183 | "ops.load(4,2000.,0.0,0.0) # place 1/2 of the weight for each node to get shear coefficient\n",
184 | " \n",
185 | "# pushover: diplacement controlled static analysis\n",
186 | "ops.integrator('DisplacementControl',3,1,0.1) # switch to displacement control, for node 11, dof 1, 0.1 increment\n",
187 | "ops.analyze(100) # apply 100 steps of pushover analysis to a displacement of 10\n",
188 | "\n",
189 | "print('Done!')\n",
190 | "\n",
191 | "\n",
192 | "\n"
193 | ]
194 | },
195 | {
196 | "cell_type": "code",
197 | "execution_count": 2,
198 | "metadata": {},
199 | "outputs": [
200 | {
201 | "data": {
202 | "image/png": "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\n",
203 | "text/plain": [
204 | "