Slackline

README.md

Pour lancer un notebook permettant de refaire ces calculs (en changeant les parametres par exemple), veuillez clicker sur le logo binder ci-dessus.

environment.yml

channels:
- conda-forge
dependencies:
- jupyterlab

slackline.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Slackline\n",
    "\n",
    "Considerons une personne C (masse 70kg, supposee ponctuelle) debout au milieu d'une slackline tendue entre 2 points A et B distants de L0=25m\n",
    "La flèche de la ligne, HC, est notée $h_1$. La hauteur de la ligne chargée, soit la hauteur du point C vaut $h_0$. La hauteur des points d'attache est donc $h_0+h_1$.\n",
    "\n",
    "![Schema](slackline.svg)\n",
    "\n",
    "## Quelques données:\n",
    "On considères 2 slacklines, l'une appelée projet44 qui présente un élongation de 9.2% sous 10kN alors que la slackline appelée Edge présente une élongation de 4% dans les mêmes conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "L0 = 25 #m longueur de la ligne\n",
    "g = 9.8 #N/kg constante de gravitation\n",
    "h0 = 0.5 #m hauteur de la slack chargée au sol\n",
    "h1 = 1.5 #m fleche de la slack\n",
    "kr_44 = 10_000/9.2e-2 # constante de raideur relative de la slackline \"projet44\"\n",
    "kr_edge = 10_000/4e-2 # constante de raideur relative de la slackline \"Edge\"\n",
    "m = 70 #kg masse de la personne\n",
    "kr = kr_44 # on travaille avec la slackline \"projet44\"\" par defaut."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calcul de la longueur de la slackline tendue\n",
    "La longeur AC est obtenue en applicant le théorème de Pythagore dans le triangle ACH rectangle en H:\n",
    "$$AC^2= AH^2+HC^2={{L_0^2}\\over{4}} + {h_1}^2 $$\n",
    "\n",
    "La longueur de la slackline tendue est donc: $$L_1 = 2 AC = 2\\sqrt{{{L_0^2}\\over{4}} + {h_1}^2}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longueur slackline tendue vaut L1 = 25.179 m\n"
     ]
    }
   ],
   "source": [
    "L1 = 2*(L0**2/4+h1**2)**0.5\n",
    "print(f\"Longueur slackline tendue vaut L1 = {L1:.3f} m\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tension de la slackline chargée\n",
    "Le slacklineur est immobile, la somme des forces appliquée est donc nulle:\n",
    "$$ \\vec{0} = \\vec{P} + \\vec{R}$$\n",
    "Le poids est donc l'opposé de la force appliquée par la slackline.\n",
    "$$ \\vec{R} = \\vec{T_1} + \\vec{T_2}$$\n",
    "La resultante des forces de tension $\\vec{R}$ étant la somme des forces appliquée vers A et vers B.\n",
    "\n",
    "La personne étant debout au centre de la ligne, les tensions $\\vec{T_1}$ et $\\vec{T_2}$ sont égales en norme et colinéaires aux vecteurs $\\vec{CA}$ et $\\vec{CB}$, respectivement. \n",
    "$$ sin(\\theta) = {{HC}\\over{AC}} = {{h_1}\\over{L_1/2}} = {{2h_1}\\over{L_1}}$$\n",
    "d'une part et d'autre part:\n",
    "$$sin(\\theta) = {{P/2}\\over{T_1}} = {{P}\\over{2T_1}}$$\n",
    "Ce qui nous permet de déduire $T_1$:\n",
    "$$ T_1 = {{P L_1}\\over{4 h_1}}$$\n",
    "Connaissant la formule du poids $\\vec{P} = m\\vec{g}$ et la forme de L_1 on obtient:\n",
    "$$ T_1 = {{m g\\sqrt{{{L_0^2}\\over{4}} + {h_1}^2}}\\over{2 h_1}}$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tension de la slackline chargée 2878.840 N\n"
     ]
    }
   ],
   "source": [
    "T1 = m*g*L1/4/h1\n",
    "print(f\"Tension de la slackline chargée { T1 :.3f} N\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Elasticité de la slackline:\n",
    "\n",
    "La slackline est considérée comme un élastique parfait de longueur au repos ${L_R}$ et de coefficient de raideur $k$.\n",
    "lorsqu'elle est étirée à une longueur $L>L_R$ elle applique une force de rappel à chacune de ses extrémités de:\n",
    "$$ T = k*(L-L_R)$$\n",
    "\n",
    "Attention, ce parametre $k$, absolu, diffère de $k_r$ qui lui est relatif (en pourcentage).\n",
    "$$ T = k_r {{(L-L_R)}\\over{L_R}}$$\n",
    "On en déduite d'une part que:\n",
    "$$ k = {{k_r}\\over{L_R}}$$\n",
    "et que:\n",
    "$$ L_R = {{ k_r L}\\over {T + k_r}} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La constante de raideur de la slackline vaut k = 4431.189 N/m et sa longueur au repos vaut LR = 24.530 m\n"
     ]
    }
   ],
   "source": [
    "LR = kr*L1/(T1 + kr)\n",
    "k = kr/LR\n",
    "print(f\"La constante de raideur de la slackline vaut k = {k:.3f} N/m et sa longueur au repos vaut LR = {LR:.3f} m\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La tension de la slackline à vide (tendue mais sans personne) vaut T0 = 2084.077 N\n"
     ]
    }
   ],
   "source": [
    "T0 = k*(L0-LR)\n",
    "print(f\"La tension de la slackline à vide (tendue mais sans personne) vaut T0 = {T0:.3f} N\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Energie potentielle élastique dans une slackline\n",
    "\n",
    "$$ E_{pe} = {{1}\\over{2}}k(L-L_R)^2$$\n",
    "\n",
    "### Pour monter sur la ligne\n",
    "\n",
    "Lorsqu'il monte sur la ligne, la personne étire la ligne de $L_0$ à $L_1$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Energie emmagsinée dans la slackline est Ep = 445.066 J\n"
     ]
    }
   ],
   "source": [
    "Esl = 0.5*k*((L1-LR)**2-(L0-LR)**2)\n",
    "print(f\"Energie emmagsinée dans la slackline est Ep = {Esl:.3f} J\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Energie potentielle de gravitation\n",
    "\n",
    "Le slacklineur doit aussi monter jusqu'au point C, d'une hauteur $h_0$ au dessus du sol.\n",
    "L'energie potentielle de gravitation s'écrit:\n",
    "$$ E_{pg} = mgh$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Energie potentielle pour monter à h0 = 0.5 m est Ep = 343.000 J doit un total de 788.066 J\n"
     ]
    }
   ],
   "source": [
    "Epg = m*g*h0\n",
    "print(f\"Energie potentielle pour monter à h0 = {h0} m est Ep = {Epg:.3f} J doit un total de {Epg+Esl:.3f} J\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le slacklineur a donc fait un effort équivalent à une denivelée de: 1.149 m\n"
     ]
    }
   ],
   "source": [
    "print(f\"Le slacklineur a donc fait un effort équivalent à une denivelée de: {(Esl+Epg)/(m*g):.3f} m\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tension de  la slackline\n",
    "Initiallement détendue, quelle énergie faut-il pour tendre la slackline?\n",
    "### Energie nécessaire:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sans frottement, il faudrait E0 = 490.091 J pour tendre la ligne de 0.470 m.\n"
     ]
    }
   ],
   "source": [
    "ET0 = 0.5*k*(L0-LR)**2\n",
    "print(f\"Sans frottement, il faudrait E0 = {ET0:.3f} J pour tendre la ligne de {L0-LR:.3f} m.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tension de la slackline à vide \n",
    "On entend par \"à vide\" la slackline tendue sans personne dessus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tension à vide de la slackline T0 = 2084.077 N\n"
     ]
    }
   ],
   "source": [
    "T0 = k * (L0-LR)\n",
    "print(f\"Tension à vide de la slackline T0 = {T0:.3f} N\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rapport de mouflage minimum nécessaire pour que le slacklineur puisse la tendre: 3.038\n"
     ]
    }
   ],
   "source": [
    "r0 = T0/(m*g)\n",
    "print(f\"Rapport de mouflage minimum nécessaire pour que le slacklineur puisse la tendre: {r0:.3f}\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si on suppose que la personne utilise tout son poids pour tendre la ligne.\n",
    "\n",
    "En théorie, il serait possible de tendre ce système avec un Buckingham 3:1 mais les frottements dans le bloqueur de sangle (banana) sont très importants (rendement estimé entre 40 et 50%, à valider).\n",
    "\n",
    "Ce rapport de mouflage doit être beaucoup plus important en pratique:\n",
    "* les mouflages sur mousquetons présentent des rendements de 50% (système primitif),\n",
    "* les mouflages sur poulies simples présentent des rendements de 70%,\n",
    "* seules les poulies sur roulements présentent des rendements supérieurs à 90%.\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "Ce document met en lumière les forces et les énergies necessaires pour tendre une slackline dans une configuration donnée. Il peut être utilisé pour:\n",
    "* Choisir une slackline en fonction de la configuration du terrain (longueur, hauteur des points d'attache, élasticité de la sangle)\n",
    "* Etablir les forces appliquées sur les points d'attache (attention, tous les calculs sont faits en statique, prévoir une marge de sécurité pour l'aspect dynamique)"
   ]
  },
  {
   "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.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}

slackline.svg