From 3cba41f49f2d91a13addea0004f7c91292d4d3e0 Mon Sep 17 00:00:00 2001 From: jaseg Date: Sun, 19 May 2019 14:43:58 +0900 Subject: Add mounting structure simulation --- driver_fw/ina226.c | 2 +- driver_fw/main.c | 2 +- frame/displacement_plot.svg | 2091 ++++++++++++++++++++ frame/frame_simulation.ipynb | 707 +++++++ frame/initial_plot.svg | 4301 +++++++++++++++++++++++++++++++++++++++++ frame/optimized_plot.svg | 4377 ++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 11478 insertions(+), 2 deletions(-) create mode 100644 frame/displacement_plot.svg create mode 100644 frame/frame_simulation.ipynb create mode 100644 frame/initial_plot.svg create mode 100644 frame/optimized_plot.svg diff --git a/driver_fw/ina226.c b/driver_fw/ina226.c index d73703b..c740125 100644 --- a/driver_fw/ina226.c +++ b/driver_fw/ina226.c @@ -5,7 +5,7 @@ void ina226_init() { /* FIXME plug in final values for I meas backchannel */ - uint16_t config = INA226_CONFIG_AVG_128 | INA226_CONFIG_VBUSCT_204u | INA226_CONFIG_VSHCT_1m1 | + uint16_t config = INA226_CONFIG_AVG_1 | INA226_CONFIG_VBUSCT_204u | INA226_CONFIG_VSHCT_4m156 | INA226_CONFIG_MODE_SHUNT | INA226_CONFIG_MODE_BUS | INA226_CONFIG_MODE_CONT; ina226_write_reg(INA226_REG_CONFIG, config); diff --git a/driver_fw/main.c b/driver_fw/main.c index ef01bfb..30ff633 100644 --- a/driver_fw/main.c +++ b/driver_fw/main.c @@ -189,7 +189,7 @@ int main(void) { TIM3->BDTR = TIM_BDTR_MOE; /* Enable timer */ TIM3->CR1 |= TIM_CR1_CEN; - /* Set f=2.5kHz/T=0.4ms */ + /* Set f=1.25kHz/T=0.8ms */ TIM3->ARR = 800-1; /* Initialize AC protocol state machine in TIM3 ISR with the AC protocol comma */ diff --git a/frame/displacement_plot.svg b/frame/displacement_plot.svg new file mode 100644 index 0000000..1b9da05 --- /dev/null +++ b/frame/displacement_plot.svg @@ -0,0 +1,2091 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/frame/frame_simulation.ipynb b/frame/frame_simulation.ipynb new file mode 100644 index 0000000..4f8fec4 --- /dev/null +++ b/frame/frame_simulation.ipynb @@ -0,0 +1,707 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Physical simulation of the polyester rope mounting structure\n", + "\n", + "This file contains a simulation of an idealized model of the polyester rope mounting structure to be used to mount the 8seg display. The rope is simulated as ideal elastic hooke springs using parameters from a rope manufacturer's website, and care is taken to keep all ropes below ~20% their breaking strength to keep reality close enough to the model. For simplicity mass is simply simulated by every knot/node having a certain mass." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy.optimize as opt\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "%matplotlib notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Global parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "g = 9.81 # earth gravity constant [m/s^2]\n", + "m = 10/146 # node mass [kg]\n", + "e = 2 # initial distance between the masses\n", + "l = 1.5 # relaxed length of the springs\n", + "\n", + "# data for 3mm cord\n", + "mbreak = 298 # [kg]\n", + "elongation_20percent_break = 0.03 # [1]\n", + "\n", + "Fbreak = mbreak * g\n", + "stiffness_3mm = (Fbreak*0.2) / elongation_20percent_break # spring stiffness\n", + "\n", + "# data for 4mm cord\n", + "mbreak = 490 # [kg]\n", + "elongation_20percent_break = 0.03 # [1]\n", + "\n", + "Fbreak = mbreak * g\n", + "stiffness_4mm = (Fbreak*0.2) / elongation_20percent_break # spring stiffness\n", + "\n", + "stiffness_thick = stiffness_4mm\n", + "stiffness_thin = stiffness_3mm\n", + "\n", + "overall_width = 62 # [m]\n", + "parabola_height_top = 1.0 # [m]\n", + "parabola_height_bottom = parabola_height_top\n", + "digit_height = 2.0 # [m]\n", + "parabola_offset = 0.4 # [m]\n", + "\n", + "anchor_offset_y_top = digit_height/2\n", + "anchor_offset_y_bottom = -digit_height/2\n", + "parabola_offset_y_top = anchor_offset_y_top + parabola_offset\n", + "parabola_offset_y_bottom = anchor_offset_y_bottom - parabola_offset\n", + "\n", + "pad_digits = 5 # pad empty digits on each side\n", + "bracing_pad = 2\n", + "digits = 25 + pad_digits*2\n", + "points_top_parabola = digits + 2 # pad 2 for tree anchors\n", + "points_top_anchor = digits + 1 # pad 1 for off-by-one\n", + "points_bottom_parabola = points_top_parabola\n", + "points_bottom_anchor = points_top_anchor" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Node positions, overall layout" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "P_top_parabola = np.zeros((points_top_parabola, 2))\n", + "P_top_anchor = np.zeros((points_top_anchor, 2))\n", + "\n", + "P_top_parabola[:,0] = np.linspace(-overall_width/2, overall_width/2, points_top_parabola)\n", + "parabola_coeff_top = parabola_height_top/((overall_width/2)**2)\n", + "P_top_parabola[:,1] = parabola_offset_y_top + parabola_coeff_top*(P_top_parabola[:,0]**2)\n", + "\n", + "P_top_anchor[:,0] = np.linspace(-overall_width/2, overall_width/2, points_top_anchor)\n", + "P_top_anchor[:,1] = anchor_offset_y_top\n", + "\n", + "P_bottom_parabola = np.zeros((points_bottom_parabola, 2))\n", + "P_bottom_anchor = np.zeros((points_bottom_anchor, 2))\n", + "\n", + "P_bottom_parabola[:,0] = np.linspace(-overall_width/2, overall_width/2, points_bottom_parabola)\n", + "parabola_coeff_bottom = parabola_height_bottom/((overall_width/2)**2)\n", + "P_bottom_parabola[:,1] = parabola_offset_y_bottom - parabola_coeff_bottom*(P_bottom_parabola[:,0]**2)\n", + "\n", + "P_bottom_anchor[:,0] = np.linspace(-overall_width/2, overall_width/2, points_bottom_anchor)\n", + "P_bottom_anchor[:,1] = anchor_offset_y_bottom\n", + "\n", + "P0 = np.vstack([P_top_parabola, P_top_anchor, P_bottom_parabola, P_bottom_anchor])\n", + "\n", + "#P0[:, 0] = np.repeat(e * np.arange(n // 2), 2)\n", + "#P0[:, 1] = np.tile((0, -e), n // 2)\n", + "#P0[-2:, 1] = [-0.5, -0.5-e]\n", + "n = len(P0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Some scaling parameters to put tension on the ropes" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "anchor_xbrance_len = 0.99\n", + "par_len_top = 0.98\n", + "par_len_bottom = 0.98\n", + "anchor_len = 0.98\n", + "xbrace_len = 0.96\n", + "overall_len_factor = 1.01" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Connectivity matrix A, edge length matrix L and stiffness matrix K\n", + "\n", + "Since this system is rather simple, we're simply using sparse connectivity matrices for everything holding two elements for every node pair." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "podoc": { + "output_text": "" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7058364644977657 (36,) (37, 37)\n", + "1.75336 (35,) (36, 36)\n", + "1.1141728717151573 (62,) (36, 36)\n", + "1.7058364644977657 (36,) (37, 37)\n", + "1.75336 (35,) (36, 36)\n", + "1.1141728717151573 (62,) (36, 36)\n", + "2.671428768134445 (62,) (36, 36)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p = bracing_pad\n", + "\n", + "A = np.zeros((n, n))\n", + "#np.eye(n, n, 1) + np.eye(n, n, 2)\n", + "i, j = points_top_parabola, points_top_parabola+points_top_anchor\n", + "k, l = j+points_bottom_parabola, j+points_bottom_parabola+points_bottom_anchor\n", + "\n", + "## Top\n", + "# parabola\n", + "A[:i, :i] = np.eye(points_top_parabola, points_top_parabola, 1)# * par_len_top\n", + "# anchor\n", + "A[i:j, i:j] = np.eye(points_top_anchor, points_top_anchor, 1)# * anchor_len\n", + "# cross-bracing\n", + "A[1+p:i-p, i+p:j-p] = np.eye(points_top_anchor-2*p, points_top_anchor-2*p, 0)# * xbrace_len\n", + "A[1+p:i-p, i+p:j-p] += np.eye(points_top_anchor-2*p, points_top_anchor-2*p, 1)# * xbrace_len\n", + "A[i-1-p, j-1-p] = 0\n", + "\n", + "## Bottom\n", + "# parabola\n", + "A[j:k, j:k] = np.eye(points_bottom_parabola, points_bottom_parabola, 1)# * par_len_bottom\n", + "# anchor\n", + "A[k:l, k:l] = np.eye(points_bottom_anchor, points_bottom_anchor, 1)# * anchor_len\n", + "# cross-bracing\n", + "A[j+1+p:k-p, k+p:l-p] = np.eye(points_bottom_anchor-2*p, points_bottom_anchor-2*p, 0)# * xbrace_len\n", + "A[j+1+p:k-p, k+p:l-p] += np.eye(points_bottom_anchor-2*p, points_bottom_anchor-2*p, 1)# * xbrace_len\n", + "A[k-1-p, l-1-p] = 0\n", + "\n", + "# Anchor cross-bracing\n", + "A[i+p:j-p, k+p:l-p] = np.eye(points_top_anchor-2*p, points_top_anchor-2*p, 1)# * anchor_xbrance_len\n", + "A[i+p:j-p, k+p:l-p] += np.eye(points_top_anchor-2*p, points_top_anchor-2*p, -1)# * anchor_xbrance_len\n", + "\n", + "\n", + "#L = l * (np.eye(n, n, 1) + np.eye(n, n, 2))\n", + "#for i in range(n // 2 - 1):\n", + "# L[2 * i + 1, 2 * i + 2] *= np.sqrt(2)\n", + "\n", + "def spring_length(i, j):\n", + " return np.sqrt((P0[i,0]-P0[j,0])**2 +\n", + " (P0[i,1]-P0[j,1])**2)\n", + "L = np.zeros((n, n))\n", + "#np.eye(n, n, 1) + np.eye(n, n, 2)\n", + "\n", + "for _i in range(n):\n", + " for _j in range(n):\n", + " L[_i, _j] = spring_length(_i, _j) * A[_i, _j]\n", + "\n", + "L[:i, :i] *= par_len_top * overall_len_factor\n", + "L[i:j, i:j] *= anchor_len * overall_len_factor\n", + "L[1:i, i:j] *= xbrace_len * overall_len_factor\n", + "L[j:k, j:k] *= par_len_bottom * overall_len_factor\n", + "L[k:l, k:l] *= anchor_len * overall_len_factor\n", + "L[j+1:k, k:l] *= xbrace_len * overall_len_factor\n", + "L[i:j, k:l] *= anchor_xbrance_len * overall_len_factor\n", + "\n", + "K = np.zeros((n, n))\n", + "K[:i, :i] = stiffness_thick # parabola top\n", + "K[i:j, i:j] = stiffness_thick # anchor top\n", + "K[1:i, i:j] = stiffness_thin # cross-bracing top parabola to anchor\n", + "K[j:k, j:k] = stiffness_thick # parabola bottom\n", + "K[k:l, k:l] = stiffness_thick # anchor bottom\n", + "K[j+1:k, k:l] = stiffness_thin # cross-bracing bottom parabola to anchor\n", + "K[i:j, k:l] = stiffness_thin # anchor cross-bracing\n", + "\n", + "\n", + "A = np.array([[k/l if l>0 else 0 for k, l in zip(ks, ls)] for ks, ls in zip(K, L)])\n", + "\n", + "#L[:i, :i] = np.eye(points_top_parabola, points_top_parabola, 1)\n", + "#L[i:j, i:j] = np.eye(points_top_anchor, points_top_anchor, 1) * 0.5\n", + "# cross-bracing\n", + "#L[1:i, i:] = np.eye(points_top_anchor, points_top_anchor, 0) * 1.4142\n", + "#L[1:i, i:] += np.eye(points_top_anchor, points_top_anchor, 1) * 1.4142\n", + "#L[i-1, j-1] = 0\n", + "\n", + "# We display a graphic representation of\n", + "# the matrix.\n", + "f, (ax1, ax2) = plt.subplots(1, 2)\n", + "ax1.matshow(L)\n", + "ax1.set_axis_off()\n", + "ax1.set_title('L')\n", + "ax2.matshow(A)\n", + "ax2.set_axis_off()\n", + "ax2.set_title('A')\n", + "\n", + "for le_slice in [(slice(0,i), slice(0,i)), (slice(i,j), slice(i,j)), (slice(1,i), slice(i,j)),\n", + " (slice(j,k), slice(j,k)), (slice(k,l), slice(k,l)), (slice(j+1,k), slice(k,l)),\n", + " (slice(i,j), slice(k,l))]:\n", + " frob = L[le_slice]\n", + " print(frob[frob != 0].mean(), frob[frob != 0].shape, frob.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Result plotting infrastructure\n", + "\n", + "We're using my blog's nice colorscheme here, and using a hand-tweaked somewhat colorblindness-friendly colormap for edge colors that's still looking fairly nice in the overall colorscheme." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "I, J = np.nonzero(A)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def dist(P):\n", + " return np.sqrt((P[:,0]-P[:,0][:,np.newaxis])**2 +\n", + " (P[:,1]-P[:,1][:,np.newaxis])**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "cmap_pos = mpl.colors.LinearSegmentedColormap('energy_pos', {\n", + " 'red': ((0., 0xfe/255, 0xfe/255), (1., 1., 1.)),\n", + " 'green': ((0., 0x3e/255, 0x3e/255), (1., .9, .9)),\n", + " 'blue': ((0., 0xa0/255, 0xa0/255), (1., 0., 0.))\n", + "}).reversed()\n", + "cmap_neg = mpl.colors.LinearSegmentedColormap('energy_neg', {\n", + " 'red': ((0., 0x08/255, 0x08/255), (1., 0., 0.)),\n", + " 'green': ((0., 0xbd/255, 0xbd/255), (1., 1., 1.)),\n", + " 'blue': ((0., 0xf9/255, 0xf9/255), (1., .5, .5))\n", + "}).reversed()\n", + "#cmap_neg = mpl.colors.LinearSegmentedColormap('energy_neg', {\n", + "# 'red': ((0., 0x01/255, 0x01/255), (1., 0., 0.)),\n", + "# 'green': ((0., 0x76/255, 0x76/255), (1., 1., 1.)),\n", + "# 'blue': ((0., 0x9D/255, 0x9D/255), (1., .5, .5))\n", + "#})\n", + "\n", + "def show_bar(P, title='No title'):\n", + " fig, ax = plt.subplots(1, 1, figsize=(9, 4.5))\n", + "\n", + " # Wall.\n", + " #ax.axvline(0, color='k', lw=3)\n", + "\n", + " # Distance matrix.\n", + " D = dist(P)\n", + "\n", + " # Get normalized elongation in [-1, 1].\n", + " elong = np.array([D[i, j] - L[i, j]\n", + " for i, j in zip(I, J)])\n", + " elong_max = elong.max()\n", + " elong_min = elong.min()\n", + " \n", + " A_foo = np.array([A[i, j]\n", + " for i, j in zip(I, J)])\n", + " a_max = A_foo[elong.argmax()]\n", + " \n", + " force = A_foo * elong\n", + " force_max = force.max()\n", + " force_min = force.min()\n", + "\n", + " # The color depends on the spring tension, which\n", + " # is proportional to the spring elongation.\n", + " colors = np.zeros((len(elong), 4))\n", + " colors[:, -1] = 1 # alpha channel is 1\n", + "\n", + " # Use two different sequentials colormaps for\n", + " # positive and negative elongations, to show\n", + " # compression and extension in different colors.\n", + " pos, neg = elong > 0, elong < 0\n", + " colors[pos] = cmap_pos(force[pos]/force_max)\n", + " colors[neg] = cmap_neg(elong[neg]/elong_min)\n", + "\n", + " # We plot the springs.\n", + " for i, j, c, is_pos in zip(I, J, colors, pos):\n", + " if is_pos:\n", + " ax.plot(P[[i, j], 0], P[[i, j], 1], lw=2, color=c)\n", + " else:\n", + " ax.plot(P[[i, j], 0], P[[i, j], 1], lw=1, color=c)\n", + "\n", + " edge_count = ((A + A.T) != 0).sum(axis=0)\n", + " single_edge = np.where(edge_count == 1)\n", + " not_single_edge = np.where(edge_count != 1)\n", + " \n", + " # We plot the masses.\n", + " ax.plot(P[not_single_edge, 0], P[not_single_edge, 1], marker='.', color='#fe3ea0')\n", + " ax.plot(P[single_edge, 0], P[single_edge, 1], marker='s', markersize=6, color='#fe3ea0')\n", + "\n", + " # We configure the axes.\n", + " # Use non-equal scaling factors for x and y to improve readability since our structure is highly elongated.\n", + " #ax.axis('equal')\n", + " ax.set_xlim(P[:, 0].min() - e,\n", + " P[:, 0].max() + e)\n", + " ax.set_ylim(P[:, 1].min() - e/4,\n", + " P[:, 1].max() + e/4)\n", + " ax.grid()\n", + " ax.set_xlabel('x [m]')\n", + " ax.set_ylabel('y [m]')\n", + " \n", + " cax1, _ = mpl.colorbar.make_axes(plt.gca(), fraction=0.05, pad=0.1)\n", + " cbar = mpl.colorbar.ColorbarBase(cax1, cmap=cmap_pos, norm=mpl.colors.Normalize(vmin=0, vmax=force_max/g),\n", + " label='Force [kg equiv., thick lines]')\n", + " cax1.yaxis.set_ticks_position('left')\n", + " cax1.yaxis.set_label_position('left')\n", + " cax2, _ = mpl.colorbar.make_axes(plt.gca(), fraction=0.475)\n", + " cbar = mpl.colorbar.ColorbarBase(cax2, cmap=cmap_neg, norm=mpl.colors.Normalize(vmin=0, vmax=-elong_min*100),\n", + " label='Slack [cm, thin lines]')\n", + "\n", + " for iax in (ax, cax1, cax2):\n", + " iax.spines['top'].set_visible(False)\n", + " iax.spines['right'].set_visible(False)\n", + " iax.spines['bottom'].set_color('#08bdf9')\n", + " iax.spines['left'].set_color('#08bdf9')\n", + " iax.tick_params(axis='x', colors='#01769D')\n", + " iax.tick_params(axis='y', colors='#01769D')\n", + " iax.xaxis.label.set_color('#01769D')\n", + " iax.yaxis.label.set_color('#01769D')\n", + " iax.grid(color='#08bdf9', linestyle=':')\n", + " \n", + " title = f'{title}, $F_{{max}} = {a_max*elong_max:.3g}[N] \\equiv {a_max*elong_max/g:.3g} [kg]$'\n", + " ax.title.set_color('#01769D')\n", + " ax.set_title(title)\n", + " \n", + " return fig" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot initial setup before simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "podoc": { + "output_text": "" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = show_bar(P0, title='Initial configuration')\n", + "fig.savefig('/tmp/initial_plot.svg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Energy function for optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def energy(P):\n", + " # The argument P is a vector (flattened matrix).\n", + " # We convert it to a matrix here.\n", + " P = P.reshape((-1, 2))\n", + " # We compute the distance matrix.\n", + " D = dist(P)\n", + " \n", + " delta_x = D - L\n", + " #delta_x[L!=0] /= L[L!=0]\n", + " delta_x = np.clip(delta_x, 0, None)\n", + " #fig, ax = plt.subplots()\n", + " #ax.imshow(A * delta_x)\n", + " \n", + " # The potential energy is the sum of the\n", + " # gravitational and elastic potential energies.\n", + " return (g * m * P[:, 1].sum() +\n", + " .5 * (A * delta_x**2).sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1741.2731117646306" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "energy(P0.ravel())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bounds for optimizer\n", + "\n", + "The layout of this data structure is a bit funky with min/maxes separately for every coordinate. See the L-BFGS-B scipy opt doc for reference." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "#bounds = np.c_[P0[:2, :].ravel(),\n", + "# P0[:2, :].ravel()].tolist() + \\\n", + "# [[None, None]] * (2 * (n - 4)) + \\\n", + "# np.c_[P0[-2:, :].ravel(),\n", + "# P0[-2:, :].ravel()].tolist()\n", + "\n", + "\n", + "bounds = np.array([[None, None]] * n*2)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "i, j = points_top_parabola, points_top_parabola+points_top_anchor\n", + "k, l = j+points_bottom_parabola, j+points_bottom_parabola+points_bottom_anchor\n", + "par_y_top = anchor_offset_y_top + parabola_offset_y_top + parabola_height_top\n", + "\n", + "bounds[0, :] = [-overall_width/2, -overall_width/2] # parabola left x\n", + "bounds[1, :] = [par_y_top, par_y_top] # parabola left y\n", + "bounds[2*i-2, :] = [overall_width/2, overall_width/2] # parabola right x\n", + "bounds[2*i-1, :] = [par_y_top, par_y_top] # parabola right y\n", + "bounds[2*i, :] = [-overall_width/2, -overall_width/2] # anchor left x\n", + "bounds[2*i+1, :] = [anchor_offset_y_top, anchor_offset_y_top] # anchor left y\n", + "bounds[2*j-2, :] = [overall_width/2, overall_width/2] # anchor right x\n", + "bounds[2*j-1, :] = [anchor_offset_y_top, anchor_offset_y_top] # anchor right y" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "i, j = points_top_parabola, points_top_parabola+points_top_anchor\n", + "k, l = j+points_bottom_parabola, j+points_bottom_parabola+points_bottom_anchor\n", + "par_y_bottom = anchor_offset_y_bottom + parabola_offset_y_bottom - parabola_height_bottom\n", + "\n", + "bounds[2*j+0, :] = [-overall_width/2, -overall_width/2] # parabola left x\n", + "bounds[2*j+1, :] = [par_y_bottom, par_y_bottom] # parabola left y\n", + "bounds[2*k-2, :] = [overall_width/2, overall_width/2] # parabola right x\n", + "bounds[2*k-1, :] = [par_y_bottom, par_y_bottom] # parabola right y\n", + "bounds[2*k, :] = [-overall_width/2, -overall_width/2] # anchor left x\n", + "bounds[2*k+1, :] = [anchor_offset_y_bottom, anchor_offset_y_bottom] # anchor left y\n", + "bounds[2*l-2, :] = [overall_width/2, overall_width/2] # anchor right x\n", + "bounds[2*l-1, :] = [anchor_offset_y_bottom, anchor_offset_y_bottom] # anchor right y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "P1 = opt.minimize(energy, P0.ravel(),\n", + " method='L-BFGS-B',\n", + " options=dict(maxfun=100000, maxiter=100000, maxls=100, gtol=1e-6),\n", + " bounds=bounds).x.reshape((-1, 2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Render result" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = show_bar(P1, title='Steady state')\n", + "fig.savefig('/tmp/optimized_plot.svg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot node displacements\n", + "\n", + "This computes and plots\n", + "1. The distance of top and bottom nodes of the digit holding lines. To much error here would lead to the digit's vertical and diagonal segments not being taut or getting overly stressed and torn apart.\n", + "2. The overall (common) droop of top and bottom digit holding lines. This will simply be visible as the display banner drooping down in the middle." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "i, j = points_top_parabola, points_top_parabola+points_top_anchor\n", + "k, l = j+points_bottom_parabola, j+points_bottom_parabola+points_bottom_anchor\n", + "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 4.5), sharex=True)\n", + "fig.subplots_adjust(hspace=0)\n", + "dist_err = -(P1[k:l] - P1[i:j])[:,1] - digit_height\n", + "ax1.plot(dist_err*100, color='#fe3ea0')\n", + "ax1.set_ylabel('distance\\nerror [cm]')\n", + "abs_disp_bot = (P1[k:l]-anchor_offset_y_bottom)[:,1]\n", + "abs_disp_top = (P1[i:j]-anchor_offset_y_top)[:,1]\n", + "ax2.plot(abs_disp_bot*100, color='#fe3ea0')\n", + "ax2.plot(abs_disp_top*100, color='#fe3ea0')\n", + "ax2.set_ylabel('absolute\\ndisplacement [cm]')\n", + "ax1.grid(), ax2.grid()\n", + "ax2.xaxis.set_minor_locator(mpl.ticker.MultipleLocator(1))\n", + "ax2.set_xlabel('digit index')\n", + "\n", + "for ax in (ax1, ax2):\n", + " ax.axvline(pad_digits, color='#ffd2e9')\n", + " ax.axvline(digits-pad_digits, color='#ffd2e9')\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " ax.spines['bottom'].set_color('#08bdf9')\n", + " ax.spines['left'].set_color('#08bdf9')\n", + " ax.tick_params(axis='x', colors='#01769D')\n", + " ax.tick_params(axis='y', colors='#01769D')\n", + " ax.xaxis.label.set_color('#01769D')\n", + " ax.yaxis.label.set_color('#01769D')\n", + " ax.grid(color='#08bdf9', linestyle=':')\n", + "\n", + "display_part = slice(pad_digits, -pad_digits-1)\n", + "dist_err_mean, dist_err_max = dist_err[display_part].mean(), np.abs(dist_err[display_part]).max()\n", + "abs_disps = np.vstack([abs_disp_bot[display_part], abs_disp_top[display_part]])\n", + "abs_disp_mean, abs_disp_max = abs_disps.mean(), np.abs(abs_disps).max()\n", + "ax1.set_title(f'Vertical displacement, $\\overline{{\\Delta d}}={dist_err_mean*100:.3g}[cm]$, $\\Delta d_{{max}}={dist_err_max*100:.3g}[cm]$, $\\overline{{\\Delta y}}={abs_disp_mean*100:.3g}[cm]$, $\\Delta y_{{max}}={abs_disp_max*100:.3g}[cm]$')\n", + "ax1.title.set_color('#01769D')\n", + "fig.savefig('/tmp/displacement_plot.svg')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/frame/initial_plot.svg b/frame/initial_plot.svg new file mode 100644 index 0000000..a32c16b --- /dev/null +++ b/frame/initial_plot.svg @@ -0,0 +1,4301 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/frame/optimized_plot.svg b/frame/optimized_plot.svg new file mode 100644 index 0000000..38541b8 --- /dev/null +++ b/frame/optimized_plot.svg @@ -0,0 +1,4377 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -- cgit