03_Reduced_scale.ipynb

{
 "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",
    "# PEC00144: Experimental Methods in Civil Engineering\n",
    "\n",
    "\n",
    "### Part I: Analysis\n",
    "[2.   Design of reduced scale models](#section_2)   \n",
    "   \n",
    "&nbsp;&nbsp;&nbsp;[2.1. Example: elastic beam under self weight](#section_21)   \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;[2.1.1. Model type \"replica\"](#section_211)   \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;[2.1.2. Model type \"equivalent\"](#section_212)   \n",
    "&nbsp;&nbsp;&nbsp;[2.2. Example: cable catenary](#section_22)   \n",
    "&nbsp;&nbsp;&nbsp;[2.3. Assignment](#section_23)   \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": 23,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>descriptor</th>\n",
       "      <th>latex</th>\n",
       "      <th>L</th>\n",
       "      <th>M</th>\n",
       "      <th>T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>Acceleration</td>\n",
       "      <td>a</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>α</th>\n",
       "      <td>Angular acceleration</td>\n",
       "      <td>\\alpha</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ω</th>\n",
       "      <td>Angular frequency</td>\n",
       "      <td>\\omega</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>Area</td>\n",
       "      <td>A</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>EA</th>\n",
       "      <td>Axial stiffness</td>\n",
       "      <td>EA</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>EI</th>\n",
       "      <td>Beam bending stiffness</td>\n",
       "      <td>EI</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>GAs</th>\n",
       "      <td>Beam shear stiffness</td>\n",
       "      <td>GA_s</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ρ</th>\n",
       "      <td>Density</td>\n",
       "      <td>\\rho</td>\n",
       "      <td>-3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>μ</th>\n",
       "      <td>Dynamic viscosity</td>\n",
       "      <td>\\mu</td>\n",
       "      <td>-1</td>\n",
       "      <td>1</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>F</th>\n",
       "      <td>Force</td>\n",
       "      <td>F</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>q</th>\n",
       "      <td>Force per unit length</td>\n",
       "      <td>q</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>f</th>\n",
       "      <td>frequency</td>\n",
       "      <td>f</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>υ</th>\n",
       "      <td>Kinematic viscosity</td>\n",
       "      <td>\\nu</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>L</th>\n",
       "      <td>Length</td>\n",
       "      <td>L</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>m</th>\n",
       "      <td>Mass</td>\n",
       "      <td>m</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>im</th>\n",
       "      <td>Mass inertia per unit length</td>\n",
       "      <td>i_m</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>μA</th>\n",
       "      <td>Mass per unit area</td>\n",
       "      <td>\\mu_A</td>\n",
       "      <td>-2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>μL</th>\n",
       "      <td>Mass per unit length</td>\n",
       "      <td>\\mu_L</td>\n",
       "      <td>-1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>M</th>\n",
       "      <td>Moment</td>\n",
       "      <td>M</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>I</th>\n",
       "      <td>Moment of inertia</td>\n",
       "      <td>I</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>W</th>\n",
       "      <td>Resistent modulus</td>\n",
       "      <td>W</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Im</th>\n",
       "      <td>Rotational mass inertia</td>\n",
       "      <td>I_m</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>k</th>\n",
       "      <td>Spring stiffness</td>\n",
       "      <td>k</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>σ</th>\n",
       "      <td>Stress</td>\n",
       "      <td>\\sigma</td>\n",
       "      <td>-1</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>t</th>\n",
       "      <td>Time</td>\n",
       "      <td>t</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>v</th>\n",
       "      <td>Velocity</td>\n",
       "      <td>v</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>Viscous damping</td>\n",
       "      <td>c</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>V</th>\n",
       "      <td>Volume</td>\n",
       "      <td>V</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                       descriptor   latex  L  M  T\n",
       "a                    Acceleration       a  1  0 -2\n",
       "α            Angular acceleration  \\alpha  0  0 -2\n",
       "ω               Angular frequency  \\omega  0  0 -1\n",
       "A                            Area       A  2  0  0\n",
       "EA                Axial stiffness      EA  1  1 -2\n",
       "EI         Beam bending stiffness      EI  3  1 -2\n",
       "GAs          Beam shear stiffness    GA_s  1  1 -2\n",
       "ρ                         Density    \\rho -3  1  0\n",
       "μ               Dynamic viscosity     \\mu -1  1 -1\n",
       "F                           Force       F  1  1 -2\n",
       "q           Force per unit length       q  0  1 -2\n",
       "f                       frequency       f  0  0 -1\n",
       "υ             Kinematic viscosity     \\nu  2  0 -1\n",
       "L                          Length       L  1  0  0\n",
       "m                            Mass       m  0  1  0\n",
       "im   Mass inertia per unit length     i_m  1  1  0\n",
       "μA             Mass per unit area   \\mu_A -2  1  0\n",
       "μL           Mass per unit length   \\mu_L -1  1  0\n",
       "M                          Moment       M  2  1 -2\n",
       "I               Moment of inertia       I  4  0  0\n",
       "W               Resistent modulus       W  3  0  0\n",
       "Im        Rotational mass inertia     I_m  2  1  0\n",
       "k                Spring stiffness       k  0  1 -2\n",
       "σ                          Stress  \\sigma -1  1 -2\n",
       "t                            Time       t  0  0  1\n",
       "v                        Velocity       v  1  0 -1\n",
       "c                 Viscous damping       c  0  1 -1\n",
       "V                          Volume       V  3  0  0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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 pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Importing pandas dataframe with dimension exponents for relevant quantities\n",
    "\n",
    "DimData = pd.read_excel('resources/DimData.xlsx', \n",
    "                         index_col  =  0,\n",
    "                         header     =  0,\n",
    "                         sheet_name = 'DimData')\n",
    "\n",
    "DimData\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Design of reduced scale models <a name=\"section_2\"></a> \n",
    "\n",
    "## 2.1. Example: elastic beam under self-weight  <a name=\"section_21\"></a> \n",
    "\n",
    "Let us design a reduced model for a reinforced concrete simply supported beam, as depicted below. \n",
    "The total span is $L = 10$m and other relevant quantities are:\n",
    "\n",
    "* Rectangular cross section:    \n",
    "  $B\\times H = 0.2 \\times 0.5{\\rm m}$    \n",
    "  Hence the section properties are:    \n",
    "  $A = 0.1{\\rm m}^2$ e $I = 0.002083 {\\rm m}^4$ <br>\n",
    "* Density of reinforced concrete:    \n",
    "  $\\rho = 2500 {\\rm kg/m}^3$    \n",
    "  Hence the mass per unit length is:    \n",
    "  $\\mu_L = \\rho A = 2500 \\times 0.1 = 250{\\rm kg/m}$ <br>\n",
    "* Young's modulus for concrete:    \n",
    "  $E_{\\rm c} = 30 \\times 10^{9} {\\rm N/m}^2$   \n",
    "  Hence the flexural stiffness is:    \n",
    "  $E_{\\rm c}I = 62.5\\times 10^6 {\\rm Nm}^2$\n",
    "\n",
    "<img src=\"resources/SimpleBeam.png\" alt=\"SimpleBeam\" width=\"480px\"/>\n",
    "\n",
    "We wish to measure the maximum displacement at beam center, $w_{\\rm max}$ caused by\n",
    "self weight. The theoretical formula for this displacement is:\n",
    "\n",
    "$$ w_{\\rm max} = \\frac{5}{384} \\frac{q L^4}{EI} $$\n",
    "\n",
    "wherer $q = \\mu_L g$, with $g \\approx 9.81{m/s^2}$.\n",
    "Replacing values gives:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Theoretical displacement at beam center is  5.11mm\n"
     ]
    }
   ],
   "source": [
    "B  = 0.2\n",
    "H  = 0.5\n",
    "L  = 10.\n",
    "ρ  = 2500.\n",
    "g  = 9.81\n",
    "E  = 3.e10\n",
    "\n",
    "A  = B*H\n",
    "I  = B*(H**3)/12\n",
    "EI = E*I\n",
    "μL = ρ*A\n",
    "q  = μL*g\n",
    "\n",
    "w_max = (5/384)*q*(L**4)/EI\n",
    "\n",
    "print('Theoretical displacement at beam center is {0:5.2f}mm'.format(1000*w_max))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The theoretical formula indicates that the governing quantities are the mass per unit length\n",
    "(or the distributed load) and the flexural stiffness.\n",
    "\n",
    "### 2.1.1. Model type \"replica\"  <a name=\"section_211\"></a>\n",
    "\n",
    "Let us now design a reduced scale model. The length scale is chosen as 1m:10m, \n",
    "while the acceleration scale must be assumed to be 1g:1g, for the model will be \n",
    "tested under the same gravity. \n",
    "Let us further assume that our model will be built with aluminum, what implies that\n",
    "the Young's modulus has as a 71GPa:30GPa scale, which is the same as the stress scale.\n",
    "\n",
    "The resulting new base is then:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>L</th>\n",
       "      <th>M</th>\n",
       "      <th>T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>L</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>σ</th>\n",
       "      <td>-1</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   L  M  T\n",
       "L  1  0  0\n",
       "a  1  0 -2\n",
       "σ -1  1 -2"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ABC    = ['L', 'a', 'σ']           # selected quantities for the new base\n",
    "LMT    = ['L', 'M', 'T']           # dimensions are the last 3 columns of DimData \n",
    "base   =  DimData.loc[ABC, LMT]    # the dimensional matrix\n",
    "i_base =  np.linalg.inv(base)      # base inversion \n",
    "\n",
    "base\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The scales for the quantities adopted for the new base are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "λ_L    =  1/10         # length scale for the reduced model\n",
    "λ_a    =  1/1          # acceleration remains unchanged (same gravity)\n",
    "λ_σ    = 71/30         # model built with aluminum instead of concrete"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we calculate the scales for further quantities that are relevant to build \n",
    "the reduced model and interpreting results.\n",
    "They could be force, $F$, distributed load, $q$, the beam cross section flexural stiffness, \n",
    "$EI$, and the mass per unit length, $\\mu_L$.\n",
    "The calculations are carried out as explained in [Class 2](https://nbviewer.jupyter.org/github/mmaiarocha/PEC00144/blob/master/2_Dimensional_analysis.ipynb). Firstly we prepare\n",
    "the dimensional matrix for the selected quantities:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>L</th>\n",
       "      <th>M</th>\n",
       "      <th>T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>F</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>q</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>EI</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>μL</th>\n",
       "      <td>-1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ρ</th>\n",
       "      <td>-3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    L  M  T\n",
       "F   1  1 -2\n",
       "q   0  1 -2\n",
       "EI  3  1 -2\n",
       "μL -1  1  0\n",
       "ρ  -3  1  0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "par    = ['F', 'q', 'EI', 'μL', 'ρ']         # selected scales to be calculated\n",
    "npar   =  len(par)                           # number of quantities\n",
    "DimMat =  DimData.loc[par, LMT]              # the dimensional matrix\n",
    "\n",
    "DimMat\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we change the base for the dimensional matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>L</th>\n",
       "      <th>a</th>\n",
       "      <th>σ</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>F</th>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>q</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>EI</th>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>μL</th>\n",
       "      <td>1.0</td>\n",
       "      <td>-1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ρ</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>-1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      L    a    σ\n",
       "F   2.0  0.0  1.0\n",
       "q   1.0  0.0  1.0\n",
       "EI  4.0  0.0  1.0\n",
       "μL  1.0 -1.0  1.0\n",
       "ρ  -1.0 -1.0  1.0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scales =  np.tile([λ_L, λ_a, λ_σ],(npar,1))  # prepare for calculations\n",
    "\n",
    "NewMat =  pd.DataFrame(data    = np.matmul(DimMat.values, i_base),\n",
    "                       index   = DimMat.index,\n",
    "                       columns = ABC)\n",
    "NewMat\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally we calculate the corresponding scales:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Force:                   λ_F  =  1:   42.25 \n",
      "Distributed load:        λ_q  =  1:    4.23 \n",
      "Flexural stiffness:      λ_EI =  1: 4225 \n",
      "Mass per unit length:    λ_μL =  1:    4.23 \n",
      "Density (!!!):         1/λ_ρ  = 24:    1\n"
     ]
    }
   ],
   "source": [
    "[λ_F, λ_q, λ_EI, λ_μL, λ_ρ]  = np.prod(scales**NewMat, axis=1)\n",
    "\n",
    "print('Force:                   λ_F  =  1:   {0:5.2f}'.format(1/λ_F),  '\\n'\n",
    "      'Distributed load:        λ_q  =  1:   {0:5.2f}'.format(1/λ_q),  '\\n'\n",
    "      'Flexural stiffness:      λ_EI =  1:{0:5.0f}'.format(1/λ_EI), '\\n'\n",
    "      'Mass per unit length:    λ_μL =  1:   {0:5.2f}'.format(1/λ_μL), '\\n'\n",
    "      'Density (!!!):         1/λ_ρ  = {0:2.0f}:    1'.format(λ_ρ))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we must calculate the dimensions of the aluminum beam that will give the required\n",
    "flexural stiffness:\n",
    "\n",
    "$$ EI = λ_{EI} \\cdot E_{\\rm c}I $$\n",
    "\n",
    "If we chose a rectangular section with dimensions $b\\times h$:\n",
    "\n",
    "\\begin{align*}\n",
    " EI &= E \\; \\frac{b h^3}{12} \\\\\n",
    " b  &= \\frac{12 EI}{E h^3}\n",
    "\\end{align*}\n",
    "\n",
    "The suitable section could be an aluminum bar with height $h = 5$cm (one tenth of\n",
    "the concrete beam height). \n",
    "Recalling that aluminum Young's modulus is 71GPa and aluminum density is 2700kg/m³\n",
    "results in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Height of aluminum bar:                5.0cm \n",
      "Width of aluminum bar:                 2.0cm \n",
      "Model required flexural stiffness:    14792Nm^2 \n",
      "Self weight of chosen aluminum strip: 2.70kg/m\n"
     ]
    }
   ],
   "source": [
    "hM  = 0.05\n",
    "EIM = λ_EI * EI\n",
    "bM  = 12*EIM/(71e9*hM**3)    # only to check the \"replica\" condition\n",
    "μLM = 2700*0.05*bM\n",
    "\n",
    "print('Height of aluminum bar:               {0:4.1f}cm'.format(100*hM), '\\n'\n",
    "      'Width of aluminum bar:                {0:4.1f}cm'.format(100*bM), '\\n'\n",
    "      'Model required flexural stiffness:    {0:4.0f}Nm^2'.format(EIM),  '\\n'\n",
    "      'Self weight of chosen aluminum strip: {0:4.2f}kg/m'.format(μLM))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The calculated width shows that the correct section respects the length scale. \n",
    "However, taking a look at the model self weight as required from the derived scale gives:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Required model self weight is 59.17kg/m\n"
     ]
    }
   ],
   "source": [
    "μLM = λ_μL * μL\n",
    "\n",
    "print('Required model self weight is {0:4.2f}kg/m'.format(μLM))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can see that the correct aluminum bar self weight is far from being reached. \n",
    "An aditional distributed mass of almost 60kg/m (!!!) must be attached to the model, otherwise the central displacement will not respect the length scale.\n",
    "This is not an easy practical task, for the attached mass _must not change the flexural \n",
    "stiffness_!\n",
    "\n",
    "If the additional mass can be included, the model central displacement results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expected model displacement at beam center is 0.511mm\n"
     ]
    }
   ],
   "source": [
    "w_max = (5/384)*μLM*g*(1.0**4)/EIM;    \n",
    "\n",
    "print('Expected model displacement at beam center is {0:5.3f}mm'.format(1000*w_max))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the displacement respects the 1:10 length scale, as expected. \n",
    "The above example illustrates how difficult it is to design structural models that accounts \n",
    "for gravity in a 1:1 scale. These models usually turn out to be very heavy.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.2. Model type \"equivalent\"  <a name=\"section_212\"></a>\n",
    "\n",
    "Another possible strategy is to chose a more flexible model. Let us, for instance,\n",
    "use an aluminum strip with section $20 \\times 5$mm. The flexural stiffness is:\n",
    "\n",
    "$$ EI = 71\\times 10^9 \\cdot \\frac{0.020 \\cdot 0.005^3}{12} \\approx 14.79{\\rm Nm^2}$$\n",
    "\n",
    "The scale for flexural stiffness now is: \n",
    "\n",
    "$$ λ_{EI} = \\frac{14.79}{62.5 \\times 10^6} \\approx 1:4225350 $$\n",
    "\n",
    "Now we set the new base:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>L</th>\n",
       "      <th>M</th>\n",
       "      <th>T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>L</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>EI</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    L  M  T\n",
       "L   1  0  0\n",
       "a   1  0 -2\n",
       "EI  3  1 -2"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ABC    = ['L', 'a', 'EI']          # selected quantities for the new base\n",
    "LMT    = ['L', 'M', 'T' ]          # dimensions are the last 3 columns of DimData\n",
    "base   =  DimData.loc[ABC, LMT]    # the dimensional matrix\n",
    "i_base =  np.linalg.inv(base)      # base inversion \n",
    "\n",
    "base\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repeating the whole calculation with the imposed scale for $EI$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Force:                 λ_F  =  1:    5282 \n",
      "Distributed load:      λ_q  =  1:   528.2 \n",
      "Flexural stiffness:    λ_EI =  1:528169 \n",
      "Mass per unit length:  λ_μL =  1:   528.2 \n",
      "Density:               λ_ρ  =  1:     5.3\n"
     ]
    }
   ],
   "source": [
    "hM     =  0.01\n",
    "bM     =  0.02\n",
    "EIM    =  7.1e10*bM*(hM**3)/12\n",
    "\n",
    "λ_L    =  1/10         # length scale for the reduced model\n",
    "λ_a    =  1/1          # acceleration remains unchanged (same gravity)\n",
    "λ_EI   =  EIM/EI       # imposed flexural stiffness scale\n",
    "\n",
    "scales =  np.tile([λ_L, λ_a, λ_EI],(npar,1))  # prepare for calculations\n",
    "\n",
    "NewMat =  pd.DataFrame(data    = np.matmul(DimMat.values, i_base),\n",
    "                       index   = DimMat.index,\n",
    "                       columns = ABC)\n",
    "\n",
    "[λ_F, λ_q, λ_EI, λ_μL, λ_ρ] = np.prod(scales**NewMat, axis=1);\n",
    "\n",
    "print('Force:                 λ_F  =  1:   {0:5.0f}'.format(1/λ_F),  '\\n'\n",
    "      'Distributed load:      λ_q  =  1:   {0:5.1f}'.format(1/λ_q),  '\\n'\n",
    "      'Flexural stiffness:    λ_EI =  1:{0:5.0f}'.format(1/λ_EI), '\\n'\n",
    "      'Mass per unit length:  λ_μL =  1:   {0:5.1f}'.format(1/λ_μL), '\\n'\n",
    "      'Density:               λ_ρ  =  1:   {0:5.1f}'.format(1/λ_ρ))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we compare the self weights of (naked) aluminum bar with the model requirement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Self weight of aluminum bar is 0.5400kg/m\n",
      "Required model self weight is  0.4733kg/m\n"
     ]
    }
   ],
   "source": [
    "μL  = 2700*0.020*0.01\n",
    "μLM = λ_μL * 250\n",
    "\n",
    "print('Self weight of aluminum bar is {0:6.4f}kg/m'.format(μL))\n",
    "print('Required model self weight is  {0:6.4f}kg/m'.format(μLM))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This new modelling strategy leads to a model that needs quite a small amount of \n",
    "additional mass to be attached. Let us take a final look at the expected displacement:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expected model displacement at beam center is 0.511mm\n"
     ]
    }
   ],
   "source": [
    "w_max = (5/384)*μLM*g*(1.0**4)/EIM; \n",
    "\n",
    "print('Expected model displacement at beam center is {0:5.3f}mm'.format(1000*w_max))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the expected result according to the specified length scale 1:10, but now with a much more economical model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2. Example: cable catenary  <a name=\"section_22\"></a> \n",
    "\n",
    "The catenary presented by a cable hanging under its self weight, $w = \\mu g$,\n",
    "can be approximated by the following formula:\n",
    "\n",
    "1. $y(x) = w x^2 / (2H)$,    is the catenary parabolic approximation,\n",
    "2. $D    = w S^2 / (8H)$,    is the sag at the span center,\n",
    "3. $L    = S + 8 D^2 /(3S)$, is total cable length, and\n",
    "4. $T    = H + wD$,          is the cable traction at both endings,\n",
    "\n",
    "where $\\mu$ is the cable mass per unit length and $g$ is the \n",
    "gravity's acceleration.\n",
    "\n",
    "<img src=\"resources/sag_tension.png\" alt=\"sag_tension\" width=\"480px\"/>\n",
    "\n",
    "In these equations, $H$ is the cable traction at its center and \n",
    "$S$ is the total horizontal span. The relation $a = H/W$ is usually\n",
    "called the _catenary constant_. \n",
    "The mean traction can be approximated by $\\bar{T} = (T+H)/2$, although\n",
    "the values $T$ and $H$ are usually quite close. \n",
    "\n",
    "Now we define problem quantities, specifying the tension and calculating the sag\n",
    "such that it can be easily measured in the model.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mass per unit length:    3.98kg/m.\n",
      "Axial stiffness:       103875kN.\n",
      "Sag at center:           9.76m.\n"
     ]
    }
   ],
   "source": [
    "g   =  9.81                         # local gravity (m/s^2)\n",
    "S   =  100.                         # total spam (m)\n",
    "H   =  5000.                        # cable tension at center (N)\n",
    "phi =  0.0254                       # cable diameter (mm)\n",
    "A   =  np.pi*((phi/2)**2)           # cross section nominal area (m^2)\n",
    "Es  =  2.05e11                      # Young's modulus for steel (Pa)\n",
    "ρs  =  7850.                        # density for steel (kg/m^3)\n",
    "\n",
    "μL  =  ρs*A                         # mass per unit length (kg/m)\n",
    "EA  =  Es*A                         # axial stiffness\n",
    "D   =  μL*g*(S**2)/(8*H)            # cable sag (m)\n",
    "\n",
    "print('Mass per unit length: {0:7.2f}kg/m.'.format(μL))\n",
    "print('Axial stiffness:      {0:7.0f}kN.'.format(EA/1000))\n",
    "print('Sag at center:        {0:7.2f}m.'.format(D))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The new base will be length, acceleration and density. This is an convenient approach\n",
    "for keeping the same gravity and designing the model to be tested in a wind tunnel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>L</th>\n",
       "      <th>M</th>\n",
       "      <th>T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>L</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ρ</th>\n",
       "      <td>-3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   L  M  T\n",
       "L  1  0  0\n",
       "a  1  0 -2\n",
       "ρ -3  1  0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ABC    = ['L', 'a', 'ρ']         # selected quantities for the new base\n",
    "LMT    = ['L', 'M', 'T' ]        # dimensions are the last 3 columns of DimData\n",
    "base   =  DimData.loc[ABC, LMT]  # the dimensional matrix\n",
    "i_base =  np.linalg.inv(base)    # base inversion \n",
    "\n",
    "λ_L    =  1/100                  # length scale for the reduced model\n",
    "λ_a    =  1/1                    # acceleration remains unchanged (same gravity)\n",
    "λ_ρ    =  1/1                    # imposed density (same fluid... air!)\n",
    "\n",
    "base\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us calculate the scales for force, mass per unit length and time. \n",
    "Recall that he axial stiffness, $EA$, has the same scale as force."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>L</th>\n",
       "      <th>M</th>\n",
       "      <th>T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>F</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>μL</th>\n",
       "      <td>-1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>t</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    L  M  T\n",
       "F   1  1 -2\n",
       "μL -1  1  0\n",
       "t   0  0  1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "par    = ['F', 'μL', 't']                    # selected scales to be calculated\n",
    "npar   =  len(par)                           # number of quantities\n",
    "DimMat =  DimData.loc[par, LMT]              # the dimensional matrix\n",
    "scales =  np.tile([λ_L, λ_a, λ_ρ],(npar,1))  # prepare for calculations\n",
    "\n",
    "DimMat\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally the required scales are calculated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Force (and axial stiffnees): λ_F  = 1:1000000\n",
      "Mass per unit length:        λ_μL = 1:  10000\n",
      "Time:                        λ_t  = 1:     10\n"
     ]
    }
   ],
   "source": [
    "NewMat = pd.DataFrame(data    = np.matmul(DimMat.values, i_base),\n",
    "                      index   = DimMat.index,\n",
    "                      columns = ABC)\n",
    "\n",
    "[λ_F, λ_μL, λ_t]  = np.prod(scales**NewMat, axis=1);\n",
    "\n",
    "print('Force (and axial stiffnees): λ_F  = 1:{0:7.0f}'.format(1/λ_F))\n",
    "print('Mass per unit length:        λ_μL = 1:{0:7.0f}'.format(1/λ_μL))\n",
    "print('Time:                        λ_t  = 1:{0:7.0f}'.format(1/λ_t))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model mass per unit length must be:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model mass per unit length:  0.398g/m.\n"
     ]
    }
   ],
   "source": [
    "μLM = λ_μL*μL\n",
    "\n",
    "print('Model mass per unit length: {0:6.3f}g/m.'.format(1000*μLM))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we take a nylon line, with Young's modulus $E = 3{\\rm GPa}$ and \n",
    "density $\\rho = 1150{\\rm kg/m^3}$,  the required diameter will be:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nylon line diameter must be: 0.210mm.\n",
      "Nylon line self weight is:   0.040g/m.\n"
     ]
    }
   ],
   "source": [
    "Eny = 3.00e9                    # nylon Young's modulus\n",
    "ρny = 1150.0                    # nylon density\n",
    "\n",
    "EAM = λ_F*EA\n",
    "dM  = 2*np.sqrt((EAM/Eny)/np.pi)\n",
    "AM  = np.pi*(dM/2)**2\n",
    "μLM = ρny*AM \n",
    "\n",
    "print('Nylon line diameter must be: {0:5.3f}mm.'.format(1000*dM))\n",
    "print('Nylon line self weight is:   {0:5.3f}g/m.'.format(1000*μLM))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The nylon line self weight is not enough and the model mass per unit length may be\n",
    "completed with lead fishing beads. \n",
    "On the other hand, the cable axial deformation may be neglected and $EA$ regarded as \n",
    "infinity. In this case, any thin line with very small bending stiffness \n",
    "could be used, as long as the model mass is respected.\n",
    "\n",
    "Finally, if the cable tension is to be measured, any load cell must be able\n",
    "to measure a force as small as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Force balance in the range of... 0.0050N.\n"
     ]
    }
   ],
   "source": [
    "HM = λ_F*H\n",
    "\n",
    "print('Force balance in the range of... {0:6.4f}N.'.format(HM))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if the cable is to be tested in a wind tunnel, the force measurement system must account for the \n",
    "expected load increase due to the aerodynamic drag.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3. Assignment  <a name=\"section_23\"></a> \n",
    "\n",
    "1. Defina um sistema estrutural simples, cuja resposta a uma dada carga possa ser calculada por uma fórmula teórica.\n",
    "2. Imagine um modelo reduzido para este sistema estrutural, escolha as grandezas que formarão a base dimensional, projete o modelo e calcule a resposta esperada no experimento.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}