{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Universidade Federal do Rio Grande do Sul (UFRGS) \n",
"Programa de Pós-Graduação em Engenharia Civil (PPGEC) \n",
"\n",
"# PEC00025: Introduction to Vibration Theory\n",
"\n",
"\n",
"### Class 10 - From single to many degrees of freedom\n",
"\n",
"[1. The stiffness and mass matrices](#section_1) \n",
"[1.1. Stiffness matrix from flexibility coefficients](#section_11) \n",
"[1.2. Lumped mass matrix](#section_12) \n",
"[2. Beam finite element and interpolation functions](#section_2) \n",
"[2.1. Stiffness matrix for a beam element](#section_21) \n",
"[2.2. Consistent mass matrix for a beam element](#section_22) \n",
"[3. Experimental model with 3 d.o.f.](#section_3) \n",
"[3.1. Stiffness matrix from displacements method](#section_31) \n",
"[2.2. Lumped mass matrix](#section_22) \n",
"[4. Assignment](#section_4) \n",
"\n",
"---\n",
"_Prof. Marcelo M. Rocha, Dr.techn._ [(ORCID)](https://orcid.org/0000-0001-5640-1020) \n",
"_Porto Alegre, RS, Brazil_ \n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# Importing Python modules required for this notebook\n",
"# (this cell must be executed with \"shift+enter\" before any other Python cell)\n",
"\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import pickle as pk\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. The stiffness and mass matrices <a name=\"section_1\"></a> \n",
"\n",
"This notebook provides three examples of _mdof_'s (multi degrees of freedom)\n",
"systems, which will be used for demonstrations in some of the following classes. \n",
"Each of these examples will show a different way of assembling the stiffness \n",
"and mass matrices:\n",
"\n",
"1. Stiffness matrix from flexibility coefficients, lumped mass matrix.\n",
"2. Stiffness matrix for a finite element through interpolation, consistent mass matrix\n",
"3. Stiffness matrix with the displacement method, lumped mass matrix.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.1. Stiffness matrix from flexibility coefficients <a name=\"section_11\"></a> \n",
"\n",
"As a first example (example 1), in order to introduce the mathematical representation \n",
"of a _mdof_ system, we will make use of the [**Ftool** software for structural analysis](https://www.ftool.com.br/Ftool/), which is a free tool for analysing plane frames,\n",
"adopted in many Engineering courses at brazilian Universities.\n",
"This computer program was developed by _Prof. Luiz Fernando Martha_ from the Department of\n",
"Civil Engineering at TecGraf/PUC, Rio de Janeiro.\n",
"\n",
"The program, however, is restricted to static analysis and cannot provide the dynamic response\n",
"of the modelled plane frames. \n",
"Nevertheless, it can be used to provide the stiffness coefficients that compose the so-called\n",
"_stiffness matrix_, one of the properties required for a dynamic analysis. \n",
"\n",
"To illustrate the meaning of stiffness coefficients, we carry on an experiment over a simply\n",
"supported steel truss with 12m span length, as shown below.\n",
"\n",
"<img src=\"images/truss12.png\" alt=\"Isostatic truss\" width=\"780px\"/>\n",
"\n",
"All truss members are made of a C-shape steel profile, as shown in the figure above. \n",
"The experiment, which could also be thought of being performed on a real structure, \n",
"consists in loading the truss at some chosen points and taking note of the \n",
"corresponding displacements.\n",
"The reference loading is applied node by node, as shown below for 5 nodes (2m apart \n",
"each other). Considering the truss simmetry, only three nodes must be loaded:\n",
"\n",
"<img src=\"images/truss12deformed.png\" alt=\"Isostatic truss\" width=\"780px\"/>\n",
"\n",
"The resulting displacements, divided by the module of the corresponding applied load, \n",
"can be arranged as columns in a matrix called _flexibility matrix_, $\\mathbf{H}$, \n",
"which must be symmetric as stated by Maxwell-Betti's reciprocity theorem.\n",
"\n",
"Considering that the system is linear elastic, undergoing small displacements, the\n",
"superposition principle may be applied.\n",
"The total displacements of chosen nodes, is a linear combination of displacements\n",
"caused by all applied forces, what in matrix notation can be expressed as:\n",
"\n",
"$$ \\vec{u} = \\mathbf{H} \\vec{F}$$\n",
"\n",
"where $\\vec{u}$ is a columns vector with the total nodal displacements and $\\vec{F}$ \n",
"is a columns vector with the applied loads. \n",
"\n",
"In the truss example above, $\\mathbf{H}$ is a $5 \\times 5$ matrix with elements\n",
"$H_{ij}$ obtained from Ftool, as given in the Python script below\n",
"(be aware of always using pure S.I. units):\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"# Flexibility coefficients in m/N\n",
"H1 = np.array([[0.0988, 0.1320, 0.1303, 0.1022, 0.0558], \n",
" [0.1320, 0.2264, 0.2325, 0.1856, 0.1022], \n",
" [0.1303, 0.2325, 0.2833, 0.2325, 0.1303], \n",
" [0.1022, 0.1856, 0.2325, 0.2264, 0.1320], \n",
" [0.0558, 0.1022, 0.1303, 0.1320, 0.0988]])*1e-6 \n",
"\n",
"F = 1000*np.array([1, 1, 1, 1, 1]).reshape(5,1)\n",
"u = np.matmul(H1,F)\n",
"\n",
"print(u)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The flexibility coefficient $H_{ij}$ in matrix $\\mathbf{H}$ represents the _generalized \n",
"displacement_ at degree of freedom $i$ caused by a unit _generalized force_ applied at \n",
"degree of freedom $j$ (and the other way around).\n",
"This is exactly the reasoning used to build the matrix in the truss example above.\n",
"\n",
"The terms _generalized displacements_ and _generalized forces_ will be better explained\n",
"in a future class, but for now it suffices to say that they may refer also to rotations\n",
"and moments, respectively.\n",
"\n",
"It must be said that the Ftool model behind the scenes has a total of \n",
"$26 \\times 3 = 78$ degrees of freedom (two displacements and one rotation per structural\n",
"node), but for the sake of didactic we are _simplifying_ the system by chosen some\n",
"_master_ nodes that eventually presents the largest displacements and may describe \n",
"satisfactorily the deformed shape of the structure as a whole. \n",
"\n",
"If now we mutiply the matrix equation above by $\\mathbf{H}^{-1} = \\mathbf{K}$ we get:\n",
"\n",
"$$ \\mathbf{K} \\vec{u} = \\vec{F} $$\n",
"\n",
"which can be recognized as an _equilibrium equation_ where the external and the \n",
"internal forces are equated. The matrix $\\mathbf{K}$ is called _stiffness matrix_. \n",
"The stiffness coefficient $K_{ij}$ in matrix $\\mathbf{K}$ represents the _generalized \n",
"reaction_ at degree of freedom $i$ caused by a unit single _generalized displacement_ \n",
"imposed at degree of freedom $j$ (and the other way around). \n",
"\n",
"For the truss example, we may calculate the stiffness matrix by inverting the \n",
"flexibility matrix as:\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"# Stiffness coefficients in N/m\n",
"K1 = np.linalg.inv(H1) \n",
"\n",
"# Visualizaton\n",
"plt.figure(1, figsize=(8,4))\n",
"plt.subplot(1,2,1); plt.imshow(H1); plt.title('Flexibility Matrix');\n",
"plt.subplot(1,2,2); plt.imshow(K1); plt.title('Stiffness Matrix');\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Most computer programs for structural analysis use the _finite element method_, \n",
"where the structure is subdivided into structural elements with well defined \n",
"elementary stiffness matrices.\n",
"The stiffness matrix representing the complete structure can be assembled by \n",
"adding up all elementary stiffnesses in the corresponding degrees of freedom. \n",
"This must be done with stiffness coefficients, for it is not possible to add up\n",
"flexibilities. \n",
"Consequently, to evaluate the displacements $\\vec{u}$ it becomes necessary \n",
"to solve a linear system. This is called _static analysis_. \n",
"\n",
"For example, let us calculate the truss displacements for a uniform load of \n",
"10kN applied to all nodes along the truss top, representing its self-weight:\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"F1 = 20000*np.ones((5,1)) # column vector, two truss nodes per master node\n",
"u1 = np.linalg.solve(K1, F1) # solve by the most effective numpy algorithm\n",
"\n",
"print('Displacement at the truss center: {0:6.2f}mm'.format(1000*u1[2,0]))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This result is not too far than the result provided by Ftool:\n",
"\n",
"<img src=\"images/truss12loaded.png\" alt=\"Isostatic truss\" width=\"780px\"/>\n",
"\n",
"which is 20.48mm (error of 0.66%).\n",
"Observe that we did not use the inversion ```numpy``` method, but a more efficient solver.\n",
"Matrix inversion is computationally much more expensive than other solution algorithms\n",
"like Gauss-Jordan elimination or Cholesky factorization.\n",
"This becomes clear as one start dealing with very large systems.\n",
"\n",
"For linear static analysis the stiffness matrix is all one needs. As was said before,\n",
"_structural analysis_ means using a mathematical model to represent the structure and\n",
"evaluate its _response_ to some given _load case_.\n",
"In static analysis load is regarded as static and so is the due response. \n",
"However, in _dynamic analysis_ load is time varying and, besides the restitutive forces\n",
"represented by the stiffness matrix, the structural system will also react with \n",
"inertial and dissipative forces.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.2. Lumped mass matrix <a name=\"section_12\"></a> \n",
"\n",
"The most simple and direct way to account for inertial forces in this simplified model\n",
"is to lump all masses in the vicinity of each (master) node and assign these lumped\n",
"masses to the corresponding degrees of freedom.\n",
"\n",
"If we define that the truss in example 1 has a distributed mass of 1000kg per unit length,\n",
"this means that to each one of the 5 model nodes will be assigned a mass equal to \n",
"$2{\\rm m} \\times 1000{\\rm kg/m} = 2000{\\rm kg}$.\n",
"Each _nodal mass_ generates an inertial force whenever an acceleration in the corresponding\n",
"degree of freedom takes place.\n",
"\n",
"Let us define the mass matrix for this example 1, to be used in following classes:\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# Lumped mass matrix in kg\n",
"M1 = 2000*np.eye(5)\n",
"\n",
"print(M1)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. Beam finite element and interpolation functions <a name=\"section_2\"></a> \n",
"\n",
"### 2.1. Stiffness matrix for a beam element <a name=\"section_21\"></a> \n",
"\n",
"As a second example (example 2), we derive the stiffness matrix for a very simple \n",
"linear elastic straight beam element. \n",
"This example is usefull to illustrate how inertial forces are accounted for \n",
"on structural systems modelled with a finite number of degrees of freedom.\n",
"In the figure below, the transversal displacement, $u(x)$ may be approximated by\n",
"a set of displacements, $u_i$, at some control degrees of freedom (usually at the\n",
"element boundaries), interpolated by a set of functions $\\varphi_i(x)$.\n",
"\n",
"<img src=\"images/interpolation.png\" alt=\"Isostatic truss\" width=\"540px\"/>\n",
"\n",
"The interpolation is carried out as a simple linear combination:\n",
"\n",
"$$ u(x) = \\sum_{i = 1}^{4}{u_i \\; \\varphi_i(x)} = \\vec{u}^{\\intercal} \\; \\vec{\\varphi}(x)$$\n",
"\n",
"where the control displacements and the interpolation functions has been\n",
"arranged as column vectors.\n",
"\n",
"Now we recall that the elastic potential energy, $V$, stored on a bended Bernoulli's \n",
"beam is given by:\n",
"\n",
"$$ V = \\frac{1}{2} \\int{EI \\left[u^{\\prime\\prime}(x) \\right]^2 \\; dx} $$\n",
"\n",
"where $EI$ is the beam bending stiffness. \n",
"Replacing the interpolated version of the transversal displacement gives:\n",
"\n",
"$$ \\left[u^{\\prime\\prime}(x) \\right]^2 = \n",
" \\sum_{i = 1}^{4} {u_i \\; \\varphi_i^{\\prime\\prime}(x)} \\cdot \n",
" \\sum_{j = 1}^{4} {u_j \\; \\varphi_j^{\\prime\\prime}(x)} =\n",
" \\vec{u}^{\\intercal} \\left[ \\vec{\\varphi}^{\\prime\\prime}(x) \\; \n",
" \\vec{\\varphi}^{\\prime\\prime\\intercal}(x) \\right] \\vec{u}$$ \n",
"\n",
"Recognizing that the control displacements are not function of $x$ leads to:\n",
"\n",
"$$ V = \\frac{1}{2} \\; \\vec{u}^{\\intercal} \\left\\{ \n",
" \\int{EI \\left[ \\vec{\\varphi}^{\\prime\\prime}(x) \\; \n",
" \\vec{\\varphi}^{\\prime\\prime\\intercal}(x) \\right] dx}\n",
" \\right\\} \\vec{u} = \n",
" \\frac{1}{2} \\; \\vec{u}^{\\intercal} \\mathbf{K} \\,\\vec{u} $$ \n",
"\n",
"The expression between curl braces is the beam element stiffness matrix, whose\n",
"elements are the stiffness coefficients calculated as:\n",
"\n",
"$$ k_{ij} = \\int{EI \\varphi_i^{\\prime\\prime}(x) \\varphi_j^{\\prime\\prime}(x) \\; dx} $$ \n",
"\n",
"The coefficients accuracy depends on the accuracy of the interpolation functions.\n",
"In the particular case of _Bernoulli's beam_ element, these functions can be the exact\n",
"solution of the elastic deformation for the imposed displacements. \n",
"Defining $\\xi = x/L$ these exact functions are:\n",
"\n",
"\\begin{align*}\n",
"\\varphi_1(\\xi) &= 1 - 3\\xi^2 + 2\\xi^3 \\\\\n",
"\\varphi_2(\\xi) &= L\\left(\\xi - 2\\xi^2 + \\xi^3 \\right) \\\\\n",
"\\varphi_3(\\xi) &= 3\\xi^2 - 2\\xi^3 \\\\\n",
"\\varphi_4(\\xi) &= L\\left(-\\xi^2 + \\xi^3 \\right)\n",
"\\end{align*}\n",
"\n",
"Let us take a look on the respective Python plots (and let them defined as \n",
"lambda functions):\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"# Beam length discretization\n",
"L = 6\n",
"x = np.linspace(0, L, 200)\n",
"\n",
"# Defining a list of lambda functions\n",
"phi = []\n",
"#phi.append(lambda xi: 1 - 3*xi*xi + 2*xi*xi*xi)\n",
"phi.append(lambda xi: 0.5 + 0.5*np.cos(np.pi*xi)) # FAKE!!!\n",
"phi.append(lambda xi: L*(xi - 2*xi*xi + xi*xi*xi))\n",
"phi.append(lambda xi: 3*xi*xi - 2*xi*xi*xi)\n",
"phi.append(lambda xi: L*(-xi*xi + xi*xi*xi ))\n",
"\n",
"# Plotting\n",
"plt.figure(2, figsize=(6, 4), clear=True)\n",
"\n",
"for k in range(4):\n",
" plt.plot(x/L, phi[k](x/L))\n",
"\n",
"plt.legend(('phi_1','phi_2','phi_3','phi_4'))\n",
"plt.xlim( 0.0, 1.0); plt.xlabel('x') \n",
"plt.ylim(-1.5, 2.5); plt.ylabel('phi(x)') \n",
"plt.grid(True)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The curvatures are calculated by differentiating the interpolation functions twice\n",
"(they are proportional to the corresponding bending moment diagrams):\n",
"\n",
"\\begin{align*}\n",
"\\varphi^{\\prime\\prime}_1(\\xi) &= \\left(-6 + 12\\xi \\right)/L^2 \\\\\n",
"\\varphi^{\\prime\\prime}_2(\\xi) &= \\left(-4 + 6\\xi \\right)/L \\\\\n",
"\\varphi^{\\prime\\prime}_3(\\xi) &= \\left( 6 - 12\\xi \\right)/L^2 \\\\\n",
"\\varphi^{\\prime\\prime}_4(\\xi) &= \\left(-2 + 6\\xi \\right)/L \n",
"\\end{align*}\n",
"\n",
"The matrix elements can be numerically evaluated as follows:\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"L = 1\n",
"nL = 1000\n",
"x = np.linspace(0, L, nL)\n",
"\n",
"# Defining a list of lambda functions\n",
"phixx = []\n",
"#phixx.append(lambda ξ: (-6 + 12*ξ)/L/L) \n",
"phixx.append(lambda ξ: -np.pi*np.pi*np.cos(np.pi*ξ)/L/L/2) # FAKE!!!\n",
"phixx.append(lambda ξ: (-4 + 6*ξ)/L ) \n",
"phixx.append(lambda ξ: ( 6 - 12*ξ)/L/L) \n",
"phixx.append(lambda ξ: (-2 + 6*ξ)/L ) \n",
"\n",
"K = np.zeros((4,4))\n",
"\n",
"for ii in range(4):\n",
" for jj in range(4):\n",
" K[ii,jj] = np.trapz(phixx[ii](x/L)*phixx[jj](x/L), dx=L/nL)\n",
"\n",
"np.set_printoptions(precision=1)\n",
"print(K)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If the integrals are analytically solved for all coefficients, the beam stiffness matrix is:\n",
"\n",
"$$ \\mathbf{K} = \\frac{EI}{L^3} \\;\n",
" \\left[ \\begin{array}{cccc}\n",
" 12 & 6L & -12 & 6L \\\\\n",
" 6L & 4L^2 & -6L & 2L^2 \\\\\n",
" -12 & -6L & 12 & -6L \\\\\n",
" 6L & 2L^2 & -6L & 4L^2\n",
" \\end{array} \\right] $$\n",
"\n",
"For the sake of future examples, the code below let this matrix defined\n",
"with some numerical values (example 2):\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"## steel rod 1m length with 6.5mm diameter\n",
"L = 1.\n",
"EI = 2.05e11*(np.pi*0.0065**4)/64\n",
"\n",
"# Stiffness coefficients in N/m\n",
"K2 = np.array([[ 12, 6*L, -12, 6*L ], \n",
" [ 6*L, 4*L*L, -6*L, 2*L*L], \n",
" [-12, -6*L, 12, -6*L ], \n",
" [ 6*L, 2*L*L, -6*L, 4*L*L]])*(EI/L/L/L) \n",
"\n",
"print('Bending stiffness: {0:5.2f}Nm2'.format(EI))\n",
"print(K2)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.2. Consistent mass matrix for a beam element <a name=\"section_22\"></a> \n",
"\n",
"After evaluating the beam element stiffness matrix, one can follow the same procedure for\n",
"evaluating the corresponding mass matrix. \n",
"If now the beam has time dependent transversal displacements, its total kinetic energy, $T$,\n",
"at a given time instant is:\n",
"\n",
"$$ T = \\frac{1}{2} \\int{\\mu \\, \\left[\\dot{u}(x) \\right]^2 \\; dx} $$\n",
"\n",
"where $\\mu$ is the beam mass per unit length. \n",
"Replacing the interpolated version of the transversal displacement gives:\n",
"\n",
"$$ \\left[ \\dot{u}(x) \\right]^2 = \n",
" \\sum_{i = 1}^{4} {\\dot{u}_i \\; \\varphi_i(x)} \\cdot \n",
" \\sum_{j = 1}^{4} {\\dot{u}_j \\; \\varphi_j(x)} =\n",
" \\dot{\\vec{u}}^{\\intercal} \\left[ \\vec{\\varphi}(x) \\; \n",
" \\vec{\\varphi}^{\\intercal}(x) \\right] \\dot{\\vec{u}}$$ \n",
"\n",
"Recognizing that the control displacements are not function of $x$ leads to:\n",
"\n",
"$$ T = \\frac{1}{2} \\; \\dot{\\vec{u}}^{\\intercal} \\left\\{ \n",
" \\int{\\mu \\left[ \\vec{\\varphi}(x) \\; \n",
" \\vec{\\varphi}^{\\intercal}(x) \\right] dx}\n",
" \\right\\} \\dot{\\vec{u}} = \n",
" \\frac{1}{2} \\; \\dot{\\vec{u}}^{\\intercal} \\mathbf{M} \\, \\dot{\\vec{u}} $$ \n",
"\n",
"The expression between curl braces is the beam element _consistent_ mass matrix, whose\n",
"elements are calculated as:\n",
"\n",
"$$ m_{ij} = \\int{\\mu \\; \\varphi_i(x) \\varphi_j(x) \\; dx} $$ \n",
"\n",
"This mass matrix is called _consistent_ because _it is evaluated by using the\n",
"same interpolation functions_ that have been used to evaluate the stiffness matrix.\n",
"These matrix elements can be numerically evaluated as follows:\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"L = 1\n",
"nL = 5000\n",
"x = np.linspace(0, L, nL)\n",
"\n",
"M = np.zeros((4,4))\n",
"\n",
"for ii in range(4):\n",
" for jj in range(4):\n",
" M[ii,jj] = np.trapz(phi[ii](x/L)*phi[jj](x/L), dx=L/nL)\n",
"\n",
"np.set_printoptions(precision=1)\n",
"print(420*M)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the particular case of Bernoulli's beam, after solving analytically the integrals above, \n",
"the consistent mass matrix results:\n",
"\n",
"$$ \\mathbf{M} = \\frac{\\mu L}{420} \\; \n",
" \\left[ \\begin{array}{cccc}\n",
" 156 & 22L & 54 & -13L \\\\\n",
" 22L & 4L^2 & 13L & -3L^2 \\\\\n",
" 54 & 13L & 156 & -22L \\\\\n",
" -13L & -3L^2 & -22L & 4L^2\n",
" \\end{array} \\right] $$\n",
"\n",
"Let us define some numerical values for this matrix, completing example 2:\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"## steel rod 1m length with 6.5mm diameter\n",
"L = 1.0\n",
"mu = 7850*(np.pi*0.0065**2)/4\n",
"\n",
"# Consistent masses in kg\n",
"M2 = np.array([[ 156, 22*L, 54, -13*L ], \n",
" [ 22*L, 4*L*L, 13*L, -3*L*L], \n",
" [ 54, 13*L, 156, -22*L ], \n",
" [-13*L, -3*L*L, -22*L, 4*L*L]])*(mu*L/420) \n",
"\n",
"print('Mass per unit length: {0:5.3f}kg/m'.format(mu))\n",
"\n",
"np.set_printoptions(precision=3)\n",
"print(M2)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3. Experimental model with 3 d.o.f. <a name=\"section_3\"></a> \n",
"\n",
"As a last example (example 3), we present an experimental model that represents\n",
"an ideal 3-storey shear building. \n",
"The model columns are regarded as massless and flexible, while the model \"_floors_\"\n",
"are perfectly stiff and concentrate all building mass.\n",
"The three degrees of freedom correspond to the horizontal displacements of each\n",
"floor, numbered from top to bottom.\n",
"\n",
"<table>\n",
" <tr>\n",
" <td><img src=\"images/model3dof.jpeg\" alt=\"Model with 3 d.o.f.\" width=\"160px\"/></td>\n",
" <td><img src=\"images/model3dof_definitions.png\" alt=\"Model definitions\" width=\"580px\"/></td>\n",
" </tr>\n",
"</table> \n",
"\n",
"According to the _displacements method_, the stiffness coeficients are the set of \n",
"generalized forces that must be applied at each degree of freedom to impose a unit\n",
"generalized displacement at each degree of freedom individually, as illustrated below:\n",
"\n",
"<img src=\"images/model3dof_stiffness.png\" alt=\"Model definitions\" width=\"580px\"/>\n",
"\n",
"Each single model columns consists of a steel strip which is 80mm long, 20mm wide \n",
"and 0.5mm thick.\n",
"Neglecting the rotation at the connections implies that the element stiffness \n",
"coefficient is $k = 12EI/L^3$, as calculated in example 2.\n",
"The displacements imposed to each degree of freedom must displace 2 or 4 columns,\n",
"what leads to the stiffness matrix below:\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"## steel rod 81x20x0.5mm\n",
"L = 0.081\n",
"EI = 2.05e11*(0.02*0.0005**3)/12\n",
"k = 12*EI/L/L/L\n",
"\n",
"# Stiffness coefficients in N/m\n",
"K3 = np.array([[ 2*k, -2*k, 0 ], \n",
" [-2*k, 4*k, -2*k], \n",
" [ 0, -2*k, 4*k]])\n",
"\n",
"print(K3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Each model floor is made up of an aluminum profile filled with lead weighting 330g.\n",
"Assigning this mass to each degree of freedom gives the lumped mass below:\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"# Lumped mass matrix in kg\n",
"M3 = np.array([[0.33, 0.00, 0.00], \n",
" [0.00, 0.33, 0.00], \n",
" [0.00, 0.00, 0.33]])\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 4. Assignments <a name=\"section_4\"></a> \n",
"\n",
"1. Proponha um modelo de estrutura que será utilizado em todas as análises até o final da disciplina. Este modelo deverá ter uma dimensão predominante para que possa ser simplificado como tendo um layout linear (por exemplo uma ponte, passarela, treliça de cobertura, edifício alto, torre, estrutura em forma de arco, etc.). A simplificação do modelo deverá ter no mínimo 10 graus de liberdade.\n",
"\n",
"2. Modele a estrutura proposta no programa F-Tool (ou outro software com a mesma capacidade) e apresente as matrizes de rigidez e de massa reduzidas. \n",
"\n",
"3. Para estruturas horizontais, calcule o deslocamento máximo por peso próprio com as matrizes simplificadas e compare este resultado com o que é dado diretamente pelo FTool. Para estruturas verticais, faça o mesmo para uma carga lateral igual a 10% do peso próprio.\n",
"\n",
"Deixe tudo pronto para ser utilizado no trabalho que será passado na próxima aula.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Appendix: Save all matrices to be used next class."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"with open('resources/data/sample_KM.pk', 'wb') as target:\n",
" pk.dump((K1, M1, K2, M2, K3, M3), target)\n",
"\n",
"#with open('resources/data/sample_KM.pk', 'rb') as target:\n",
"# K1, M1, K2, M2, K3, M3 = pk.load(target)\n"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.9"
}
},
"nbformat": 4,
"nbformat_minor": 2
}