diff --git a/source/Exercice-solution.ipynb b/source/Exercice-solution.ipynb new file mode 100644 index 0000000..3567e15 --- /dev/null +++ b/source/Exercice-solution.ipynb @@ -0,0 +1,727 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bf0cd470", + "metadata": {}, + "source": [ + "# Exercice" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c0302414", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from scipy.optimize import curve_fit" + ] + }, + { + "cell_type": "markdown", + "id": "908b1a9d", + "metadata": {}, + "source": [ + "### Data generation" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "76ccfc6f", + "metadata": {}, + "outputs": [], + "source": [ + "# constants\n", + "g = 10.\n", + "V0 = 1.\n", + "H = 1." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d58ffe3e", + "metadata": {}, + "outputs": [], + "source": [ + "# Model \n", + "l = V0 * np.sqrt(2.*H/g)" + ] + }, + { + "cell_type": "markdown", + "id": "9a03ead6", + "metadata": {}, + "source": [ + "### Données\n", + "pour file \"V1msHvariable.csv\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dd458e01", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.40 0.80 0.01\n", + "0.42 0.90 0.01\n", + "0.45 1.00 0.01\n", + "0.47 1.10 0.01\n", + "0.49 1.20 0.01\n" + ] + } + ], + "source": [ + "#\n", + "error = 0.01\n", + "for h in [0.8, 0.9,1,1.1,1.2]:\n", + " l = V0 * np.sqrt(2.*h/g)\n", + " print('{0:.2f} {1:0.2f} {2:.2f}'.format(l,h,error))" + ] + }, + { + "cell_type": "markdown", + "id": "a06afab7", + "metadata": {}, + "source": [ + "### Données\n", + "pour file \"H1mVvariable.csv\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ca4407db", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.45 1.00 0.10\n", + "0.54 1.20 0.10\n", + "0.67 1.50 0.10\n", + "0.89 2.00 0.10\n", + "1.34 3.00 0.10\n" + ] + } + ], + "source": [ + "error = 0.1\n", + "for v in [1, 1.2,1.5,2,3]:\n", + " l = v * np.sqrt(2.*H/g)\n", + " print('{0:.2f} {1:0.2f} {2:.2f}'.format(l,v,error))" + ] + }, + { + "cell_type": "markdown", + "id": "81b6f7b3", + "metadata": {}, + "source": [ + "## Solution" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a748d198", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# import image module\n", + "from IPython.display import Image\n", + " \n", + "# get the image\n", + "Image(url=\"experience.png\", width=500, height=500)" + ] + }, + { + "cell_type": "markdown", + "id": "301b6ab8", + "metadata": {}, + "source": [ + " Une bille supposée ponctuelle avec une vitesse horizontale $V_0$ tombe d'une table de hauteur $H$ et rencontre le sol à une longueur $L$.\n", + "\n", + "Nous disposons de deux fichiers de mesures expérimentales (fichiers formatés csv séparés par des \";\")\n", + "- \"V1msHvariable.csv\" expérience de mesure de la longueur $L$ à vitesse $V_0=1 \\ m/s$ constante pour des différentes hauteurs $H$ avec l'erreur correspondante\n", + "- \"H1mVvariable.csv\" expérience de mesure de la longueur $L$ à hauteur $H= 1 \\ m$ constante pour des différentes vitesses $V_0$ avec l'erreur correspondante\n", + "\n", + "On propose un modèle pour la longueur $L$\n", + "\n", + "$$ L = C V_0^\\alpha H^\\beta $$\n", + "\n", + "nous allons évaluer les coefficients $\\alpha$ et $\\beta$, ainsi que la constante $C$." + ] + }, + { + "cell_type": "markdown", + "id": "bb58b946", + "metadata": {}, + "source": [ + "### Point 1.1\n", + "En utilisant la bibliothèque Pandas, lisez le fichier \"V1msHvariable.csv\" et définisez les variables $L$, $H$, \n", + "et $erreur$ (de la mesure de hauteur)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8aa94441", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " L H error\n", + "0 0.40 0.8 0.01\n", + "1 0.42 0.9 0.01\n", + "2 0.45 1.0 0.01\n", + "3 0.47 1.1 0.01\n", + "4 0.49 1.2 0.01\n" + ] + } + ], + "source": [ + "d = pd.read_csv(\"V1msHvariable.csv\",delimiter=\";\")\n", + "print(d)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "296b12e0", + "metadata": {}, + "outputs": [], + "source": [ + "d.head()\n", + "# taking values from headers\n", + "L = d[\"L\"]\n", + "H = d[\"H\"]\n", + "e = d[\"error\"]" + ] + }, + { + "cell_type": "markdown", + "id": "fc7a10ed", + "metadata": {}, + "source": [ + "### Point 1.2\n", + "Faites une figure de $L$ vs $H$ avec barres d'erreur" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d8aab11d", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "67ec753b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(6,6)) # s\n", + "ax = plt.subplot() \n", + "ax.errorbar(H,L,e, marker='.', linestyle=\"none\", label=\"data\")\n", + "ax.set_title(\"L vs H\")\n", + "ax.set_xlabel(\"H[m]\")\n", + "ax.set_ylabel(\"L[m]\")\n", + "ax.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "a84939cd", + "metadata": {}, + "source": [ + "### Point 1.3\n", + "Utilisez la fonction \"curve_fit\" pour faire une regression linéaire des données exprimées en une échelle log-log\n", + "et trouve la valeur de $\\alpha$" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4d6afbe8", + "metadata": {}, + "outputs": [], + "source": [ + "# fit\n", + "def func(x, a, b):\n", + " return a * x + b" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "db8be79d", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.optimize import curve_fit" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b1b62edc", + "metadata": {}, + "outputs": [], + "source": [ + "popt= curve_fit(func, np.log(H), np.log(L))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "10616c91", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a = 0.512\n", + "b= -0.805\n" + ] + } + ], + "source": [ + "popt[0]\n", + "a=popt[0][0]\n", + "b=popt[0][1]\n", + "print(\"a = %.3f\" % a)\n", + "print(\"b= %.3f\" % b)" + ] + }, + { + "cell_type": "markdown", + "id": "763aab30", + "metadata": {}, + "source": [ + "### Point 1.4\n", + "Faites un figure log-log de $L$ vs $H$ en ajoutant la regression linéaire trouvée dans le point précédent" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5403d854", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(6,6)) # s\n", + "ax = plt.subplot() \n", + "ax.errorbar(H,L,e, marker='.', linestyle=\"none\", label=\"data\")\n", + "ax.plot(H,np.exp(b)*H**a,\"-\",label=\"model\")\n", + "ax.set_title(\"with error bars\")\n", + "ax.set_title(\"L vs H\")\n", + "ax.set_xlabel(\"H[m]\")\n", + "ax.set_ylabel(\"L[m]\")\n", + "ax.legend()\n", + "ax.loglog()" + ] + }, + { + "cell_type": "markdown", + "id": "07f7c827", + "metadata": {}, + "source": [ + "Estimation de la constante $C$" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "d619b153", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0.447214\n", + "1 0.442719\n", + "2 0.450000\n", + "3 0.448127\n", + "4 0.447307\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "C=L/H**0.5\n", + "print(C)" + ] + }, + { + "cell_type": "markdown", + "id": "9f02fc0f", + "metadata": {}, + "source": [ + "## Partie 2\n", + "Etude de la longueur $L$ à hauteur $H= 1 \\ m$ constante pour des différentes vitesses $V_0$ " + ] + }, + { + "cell_type": "markdown", + "id": "4692da2f", + "metadata": {}, + "source": [ + "### Point 2.1\n", + "En utilisant la bibliothèque Pandas, lisez le fichier \"H1mVvariable.csv\" et définisez les variables $L$, $V_0$, \n", + "et $erreur$ (de la mesure de vitesse)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "86a78bb1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " L V error\n", + "0 0.45 1.0 0.1\n", + "1 0.54 1.2 0.1\n", + "2 0.67 1.5 0.1\n", + "3 0.89 2.0 0.1\n", + "4 1.34 3.0 0.1\n" + ] + } + ], + "source": [ + "d = pd.read_csv(\"H1mVvariable.csv\",delimiter=\";\")\n", + "print(d)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9d9b92cc", + "metadata": {}, + "outputs": [], + "source": [ + "# taking values from headers\n", + "L = d[\"L\"]\n", + "V = d[\"V\"]\n", + "e = d[\"error\"]" + ] + }, + { + "cell_type": "markdown", + "id": "bcc73921", + "metadata": {}, + "source": [ + "### Point 2.2\n", + "Faites une figure de $L$ vs $V_0$ avec barres d'erreur" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "2b001194", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(6,6)) # s\n", + "ax = plt.subplot() \n", + "ax.errorbar(V,L,e, marker='.', linestyle=\"none\", label=\"data\")\n", + "ax.set_title(\"with error bars\")\n", + "ax.set_title(\"L vs $V_0$\")\n", + "ax.set_xlabel(\"$V_0$[m/s]\")\n", + "ax.set_ylabel(\"L[m]\")\n", + "ax.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "70f7b0cd", + "metadata": {}, + "source": [ + "### Point 2.3\n", + "Utilisez la fonction \"curve_fit\" pour faire une regression linéaire des données exprimées en une échelle log-log\n", + "et trouve la valeur de $\\beta$" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "21162560", + "metadata": {}, + "outputs": [], + "source": [ + "popt= curve_fit(func, np.log(V), np.log(L))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "ad96315b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a = 0.991\n", + "b = -0.800\n" + ] + } + ], + "source": [ + "popt[0]\n", + "a=popt[0][0]\n", + "b=popt[0][1]\n", + "print(\"a = %.3f\" % a)\n", + "print(\"b = %.3f\" % b)" + ] + }, + { + "cell_type": "markdown", + "id": "8b31f498", + "metadata": {}, + "source": [ + "### Point 2.4\n", + "Faites un figure log-log de $L$ vs $V_0$ en ajoutant la regression linéaire trouvée dans le point précédent" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "78a36fc1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(6,6)) # s\n", + "ax = plt.subplot() \n", + "ax.errorbar(V,L,e, marker='.', linestyle=\"none\", label=\"data\")\n", + "ax.plot(V,np.exp(b)*V**a,\"-\",label=\"model\")\n", + "ax.set_title(\"with error bars\")\n", + "ax.set_title(\"L vs $V_0$\")\n", + "ax.set_xlabel(\"$V_0$[m/s]\")\n", + "ax.set_ylabel(\"L[m]\")\n", + "ax.legend()\n", + "ax.loglog()" + ] + }, + { + "cell_type": "markdown", + "id": "b27babbe", + "metadata": {}, + "source": [ + "Estimation de la constante $C$" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "6ae3c7c3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0.450000\n", + "1 0.450000\n", + "2 0.446667\n", + "3 0.445000\n", + "4 0.446667\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "C1=L/V\n", + "print(C1)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e34d2bdb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.447073328032969 0.44766666666666677\n" + ] + } + ], + "source": [ + "print(C.mean(),C1.mean())" + ] + }, + { + "cell_type": "markdown", + "id": "c215342d", + "metadata": {}, + "source": [ + "Le modèle peut s'écrire donc\n", + "$$L = C V H^{1/2}$$\n", + "avec $C=0.447$.\n", + " L'unité de $C$ est $\\sqrt{T^2/L}$\n", + "$$ L = [C] L/T L^{1/2}$$.\n", + "\n", + "Comme le moteur de la chute c'est la gravité et $[g] = L/T^2$ nous pouvons écrire\n", + "$$ C = \\sqrt{2/ g}$$ alors\n", + "$$ L = V_0 \\sqrt{ \\frac{2 H}{g}}$$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca1f0efd", + "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.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/source/Exercice.ipynb b/source/Exercice.ipynb new file mode 100644 index 0000000..06502e1 --- /dev/null +++ b/source/Exercice.ipynb @@ -0,0 +1,282 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f18c4520", + "metadata": {}, + "source": [ + "### Problème" + ] + }, + { + "cell_type": "markdown", + "id": "a911f63f", + "metadata": {}, + "source": [ + "Nous allons anayser les données de l'expérience de la figure" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "bf4e3b36", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# import image module\n", + "from IPython.display import Image\n", + " \n", + "# get the image\n", + "Image(url=\"experience.png\", width=500, height=500)\n" + ] + }, + { + "cell_type": "markdown", + "id": "ecffdbd7", + "metadata": {}, + "source": [ + " Une bille supposée ponctuelle avec une vitesse horizontale $V_0$ tombe d'une table de hauteur $H$ et rencontre le sol à une longueur $L$.\n", + "\n", + "Nous disposons de deux fichiers de mesures expérimentales (fichiers formatés csv séparés par des \";\")\n", + "- \"V1msHvariable.csv\" expérience de mesure de la longueur $L$ à vitesse $V_0=1 \\ m/s$ constante pour des différentes hauteurs $H$ avec l'erreur correspondante\n", + "- \"H1mVvariable.csv\" expérience de mesure de la longueur $L$ à hauteur $H= 1 \\ m$ constante pour des différentes vitesses $V_0$ avec l'erreur correspondante\n", + "\n", + "On propose un modèle pour la longueur $L$\n", + "\n", + "$$ L = C V_0^\\alpha H^\\beta $$\n", + "\n", + "nous allons évaluer les coefficients $\\alpha$ et $\\beta$, ainsi que la constante $C$." + ] + }, + { + "cell_type": "markdown", + "id": "def2a595", + "metadata": {}, + "source": [ + "### Bibliothèques nécessaires" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6eb47ffa", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from scipy.optimize import curve_fit" + ] + }, + { + "cell_type": "markdown", + "id": "f60f3bdf", + "metadata": {}, + "source": [ + "## Partie 1\n", + "Etude de la longueur 𝐿 à vitesse $𝑉_0=1 \\ 𝑚/𝑠$ constante pour des différentes hauteurs 𝐻" + ] + }, + { + "cell_type": "markdown", + "id": "d135c405", + "metadata": {}, + "source": [ + "### Point 1.1\n", + "En utilisant la bibliothèque Pandas, lisez le fichier \"V1msHvariable.csv\" et définisez les variables $L$, $H$, \n", + "et $erreur$ (de la mesure de hauteur)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "96e320c8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "d7a43f3e", + "metadata": {}, + "source": [ + "### Point 1.2\n", + "Faites une figure de $L$ vs $H$ avec barres d'erreur" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "358a3d61", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "c7139233", + "metadata": {}, + "source": [ + "### Point 1.3\n", + "Utilisez la fonction \"curve_fit\" pour faire une regression linéaire des données exprimées en une échelle log-log\n", + "et trouve la valeur de $\\alpha$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2dbb6367", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "70ed4d67", + "metadata": {}, + "source": [ + "### Point 1.4\n", + "Faites un figure log-log de $L$ vs $H$ en ajoutant la regression linéaire trouvée dans le point précédent" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83e8da5f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "8691357e", + "metadata": {}, + "source": [ + "## Partie 2\n", + "Etude de la longueur $L$ à hauteur $H= 1 \\ m$ constante pour des différentes vitesses $V_0$ " + ] + }, + { + "cell_type": "markdown", + "id": "8dde6329", + "metadata": {}, + "source": [ + "### Point 2.1\n", + "En utilisant la bibliothèque Pandas, lisez le fichier \"H1mVvariable.csv\" et définisez les variables $L$, $V_0$, \n", + "et $erreur$ (de la mesure de vitesse)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ec90d54e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "b5f8fbca", + "metadata": {}, + "source": [ + "### Point 2.2\n", + "Faites une figure de $L$ vs $V_0$ avec barres d'erreur" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a37afbd6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "94d89467", + "metadata": {}, + "source": [ + "### Point 2.3\n", + "Utilisez la fonction \"curve_fit\" pour faire une regression linéaire des données exprimées en une échelle log-log\n", + "et trouve la valeur de $\\beta$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53017788", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "a61554ae", + "metadata": {}, + "source": [ + "### Point 2.4\n", + "Faites un figure log-log de $L$ vs $V_0$ en ajoutant la regression linéaire trouvée dans le point précédent" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e62b8263", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "7f2178cf", + "metadata": {}, + "source": [ + "## Partie 3 (optative)\n", + "Donnez une estimation de la constante $C$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2cff8e1c", + "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.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/source/H1mVvariable.csv b/source/H1mVvariable.csv new file mode 100644 index 0000000..2fb5df3 --- /dev/null +++ b/source/H1mVvariable.csv @@ -0,0 +1,6 @@ +L;V;error +0.45;1.00;0.10 +0.54;1.20;0.10 +0.67;1.50;0.10 +0.89;2.00;0.10 +1.34;3.00;0.10 diff --git a/source/V1msHvariable.csv b/source/V1msHvariable.csv new file mode 100644 index 0000000..b94abe1 --- /dev/null +++ b/source/V1msHvariable.csv @@ -0,0 +1,6 @@ +L;H;error +0.40;0.80;0.01 +0.42;0.90;0.01 +0.45;1.00;0.01 +0.47;1.10;0.01 +0.49;1.20;0.01 \ No newline at end of file diff --git a/source/experience.png b/source/experience.png new file mode 100644 index 0000000..24b5b8d Binary files /dev/null and b/source/experience.png differ