diff --git a/anaconda_envs.png b/anaconda_envs.png
new file mode 100644
index 0000000000000000000000000000000000000000..568ffaf8fa3815892d6c337db09bb201c5cc9e4a
Binary files /dev/null and b/anaconda_envs.png differ
diff --git a/anaconda_path.png b/anaconda_path.png
new file mode 100644
index 0000000000000000000000000000000000000000..2037da23816626a72164df77a62857fcc6fcb212
Binary files /dev/null and b/anaconda_path.png differ
diff --git a/anaconda_progs.png b/anaconda_progs.png
new file mode 100644
index 0000000000000000000000000000000000000000..d8657522b577f6d91276631b6059da092270e2d7
Binary files /dev/null and b/anaconda_progs.png differ
diff --git a/anaconda_spyder.png b/anaconda_spyder.png
new file mode 100644
index 0000000000000000000000000000000000000000..836d36496306e0ae060d845808f7190ef3ee2719
Binary files /dev/null and b/anaconda_spyder.png differ
diff --git a/anaconda_update.png b/anaconda_update.png
new file mode 100644
index 0000000000000000000000000000000000000000..aa9ff45e02f89c7be341775e6bf2d23f5a0f00b1
Binary files /dev/null and b/anaconda_update.png differ
diff --git a/anaconda_web.png b/anaconda_web.png
new file mode 100644
index 0000000000000000000000000000000000000000..99d5b2e34a4aacca851fec1495b19aa014a68884
Binary files /dev/null and b/anaconda_web.png differ
diff --git a/hw-guidelines.ipynb b/hw-guidelines.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..9a7eaeeff3e2c94d1fcdfe18886068d24bb03c97
--- /dev/null
+++ b/hw-guidelines.ipynb
@@ -0,0 +1,1611 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "545b1695-b5e7-450d-8f3c-2b609abc5c07",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "# Python environment setup\n",
+    "\n",
+    "## Which python?\n",
+    "\n",
+    "At least you will need a basic python interpreter as well as the popular python scientific libraries:\n",
+    "\n",
+    "- numpy: matrix/vector types with basic linear algebra routines.\n",
+    "  \n",
+    "- scipy: advanced algorithms (e.g. sparse linear solvers).\n",
+    "  \n",
+    "- matplotlib: display of 2D and 3D plots.\n",
+    "\n",
+    "If you already have a python distribution on your computer, use it. \n",
+    "\n",
+    "There are many ways to install python. Some examples:\n",
+    "\n",
+    "- Available in all Linux distributions ( `apt install python3` on Ubuntu).\n",
+    "  \n",
+    "- [Python.org](python.org): the reference binaries available from the official python website. <br/> You should use \"PyPI\" (`pip` command) for the 3 missing modules: <br/>\n",
+    "  `pip install numpy scipy matplotlib`  <br/>This is the cheapest option in terms of disk space (<0.5Gb).\n",
+    "\n",
+    "- [Anaconda](https://www.anaconda.com/): full IDE around ``conda''. Features: package management, multi-python environments and optimised proprietary libraries (Intel MKL, NVIDIA CUDA). <br/> (comes with >10Gb of libraries/programs already installed, as well as a text editor - no command line needed).\n",
+    "\n",
+    "  \n",
+    "- [Miniconda](https://conda.io/miniconda.html): minimal conda environment - requires the installation of packages with the command line  ($\\approx$1.6Gb on disk).<br/> `conda install numpy scipy matplotlib`\n",
+    "\n",
+    "$\\Rightarrow$ You may choose **Anaconda** if you are not familiar with programming and/or the command line.\n",
+    "\n",
+    "## Anaconda installation\n",
+    "\n",
+    "- Go to https://www.anaconda.com/download/\n",
+    "  \n",
+    "- Download the installer for your OS:\n",
+    "\n",
+    "![](anaconda_web.png)\n",
+    "\n",
+    "- Download the installer for your system (it should be auto-detected).\n",
+    "  \n",
+    "- Start the installer and follow the instructions.\n",
+    "\n",
+    "- Uncheck python registration if you plan to use other python versions for other projects:\n",
+    "\n",
+    "![](anaconda_path.png)\n",
+    "\n",
+    "- Run ``Anaconda Navigator'' (from your Start Menu if Windows):\n",
+    " \n",
+    "![](anaconda_progs.png)\n",
+    "\n",
+    "- Lots of (too many?) programs have been installed. You just need the \"Spyder IDE\", which can be run from outside this application.\n",
+    "\n",
+    "- Anaconda may ask you to perform an update of \"Anaconda Navigator\":\n",
+    " \n",
+    "![](anaconda_update.png) \n",
+    "  \n",
+    "- It is a **bad idea** to update the base environment. The update procedure might fail leading the program to an unstable state!\n",
+    "  \n",
+    "- The same remark holds for Spyder or any other python package.\n",
+    "\n",
+    "- If you have previously installed an old version of Anaconda for another project, you can create a new and clean ``python 3'' environment:\n",
+    "\n",
+    "![](anaconda_envs.png)\n",
+    "  \n",
+    "- Anaconda is able to handle several versions of python in separate environments.\n",
+    "\n",
+    "- Launch ``Spyder'' (IDE similar to the one of MATLAB):\n",
+    "\n",
+    "![](anaconda_spyder.png)\n",
+    "\n",
+    "## How to learn Python?\n",
+    "\n",
+    "- Use the links from the \"help\" menu:\n",
+    "  \n",
+    "![](anaconda_help.png)\n",
+    "\n",
+    "- Use `CTRL-I` when your cursor is above any unknown command.\n",
+    "\n",
+    "- Free Python books from Springer: https://lib.uliege.be/\n",
+    "\n",
+    "- If you are familiar with MATLAB:\n",
+    "    - [translation of MATLAB commands](http://mathesaurus.sourceforge.net/matlab-numpy.html)\n",
+    "    - [numpy for MATLAB users](https://numpy.org/doc/stable/user/numpy-for-matlab-users.html)\n",
+    "\n",
+    "# Introduction to (scientific) Python\n",
+    "\n",
+    "## Basic calculations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "18d32e8c-5a28-4c70-baca-22ca9487a7eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "c = 1.7071067811865475\n"
+     ]
+    }
+   ],
+   "source": [
+    "# -*- coding: utf-8 -*-\n",
+    "# the line above allows you to use UTF8 characters in your file\n",
+    "\n",
+    "import math               # loads the 'math' module from python packages\n",
+    "\n",
+    "a = 1                     # a is an integer! use 1.0 or 1. for floats\n",
+    "b = math.pi/4             # use a \"dot\" to access 'math' functions/variables    \n",
+    "c = a + math.sin(b)       # \"dir(math)\" displays all math functions\n",
+    "print('c =', c)           # strings such as 'c =' could also use double quotes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "233a479c-61ef-4b76-b8be-01bc87c0d2bb",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "## Arrays / loops / conditional statements"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b81213f2-ab0f-476f-913c-bb6ff3bea9bd",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "testing  1\n",
+      "1  is odd\n",
+      "testing  2\n",
+      "2  is even\n",
+      "testing  3\n",
+      "3  is odd\n",
+      "testing  5\n",
+      "5  is odd\n",
+      "testing  8\n",
+      "8  is even\n",
+      "testing  11\n",
+      "11  is odd\n",
+      "testing  20\n",
+      "20  is even\n"
+     ]
+    }
+   ],
+   "source": [
+    "vals = [1, 2, 3, 5, 8, 11, 20]  # this is a python array (called \"list\")\n",
+    "for v in vals:                  # for loop: v is the iteration variable\n",
+    "    print('testing ', v)        # the body of the for loop is indented\n",
+    "    if v % 2 == 0:              # % is the modulo operator\n",
+    "        print(v, ' is even')    # once again, use indentation for the body\n",
+    "    else:\n",
+    "        print(v, ' is odd')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f1ab824e-4d94-4176-bead-1fa9e8a6c3c4",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "## Functions\n",
+    "Prefer functions to \"copying/pasting\" code!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c1f5c0f7-7948-45cf-b8b7-18166e2c0930",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.09983341664682815"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def f(A, omega, t=0.0):             # function f has 3 parameters\n",
+    "    \"\"\"here goes the documentation string\"\"\"\n",
+    "    return A*math.sin(omega*t)\n",
+    "\n",
+    "f(1.0, 10.0, 0.01)                   # evaluation for A=1, omega=10 and t=0.01 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a833adac-51fc-4d20-9132-bf1087a64f88",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.0"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f(1.0, 10.0)                         # uses t=0.0 (default value)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "98b75c4f-5d58-4f3f-b935-e9dcba6d6ef5",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "## Vectors, matrices (and beyond)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3f95bd4e-d6ca-43b3-beae-184239c2c5e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(3,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np                   # we will write np.* instead of numpy.*\n",
+    "\n",
+    "a = [1., 2., 3.]                     # python \"list\" (no math operators)\n",
+    "a = (1., 2., 3.)                     # python \"tuple\" (immutable array)\n",
+    "\n",
+    "a = np.array([1., 2., 3.])           # numpy column-vector (very efficient)\n",
+    "a[0] = 0.                            # indices start at 0! (as in C)\n",
+    "print(a.shape)                       # displays (3,) which is a tuple of size 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89e10ae4-2b5d-4daa-92a9-fd13d9d20bdc",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "note: $\\texttt{a}$ is a column vector (3 rows, 1 column)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "7bb32295-2c9f-48d7-944b-34e53f885915",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(3, 4)\n"
+     ]
+    }
+   ],
+   "source": [
+    "B = np.array([[ 11, 12, 13, 14 ],\n",
+    "              [ 21, 22, 23, 24 ],\n",
+    "              [ 31, 32, 33, 34 ]])   # numpy matrix      \n",
+    "print(B.shape)                       # displays (3, 4) as \"size()\" in MATLAB"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "72db949a-4681-48dc-9bb7-998d0faf2962",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1.   1.1  1.2  1.3\n",
+      "  1.4  1.5  1.6  1.7  1.8  1.9  2.   2.1  2.2  2.3  2.4  2.5  2.6  2.7\n",
+      "  2.8  2.9  3.   3.1  3.2  3.3  3.4  3.5  3.6  3.7  3.8  3.9  4.   4.1\n",
+      "  4.2  4.3  4.4  4.5  4.6  4.7  4.8  4.9  5.   5.1  5.2  5.3  5.4  5.5\n",
+      "  5.6  5.7  5.8  5.9  6.   6.1  6.2  6.3  6.4  6.5  6.6  6.7  6.8  6.9\n",
+      "  7.   7.1  7.2  7.3  7.4  7.5  7.6  7.7  7.8  7.9  8.   8.1  8.2  8.3\n",
+      "  8.4  8.5  8.6  8.7  8.8  8.9  9.   9.1  9.2  9.3  9.4  9.5  9.6  9.7\n",
+      "  9.8  9.9 10. ]\n"
+     ]
+    }
+   ],
+   "source": [
+    "b = np.linspace(0., 10., 101)        # 101 values from 0. to 10.\n",
+    "print(b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f56e9114-dfc8-4f06-b9bd-94b6700e6ccc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1. 2. 3. 4.]\n"
+     ]
+    }
+   ],
+   "source": [
+    "c = np.arange(1., 5.)                # c = [1. 2. 3. 4.]\n",
+    "print(c)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "6ba86ed3-10ad-407a-8fea-1f6fa172fe1e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[0. 0. 0.]\n",
+      " [0. 0. 0.]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "C = np.zeros( (2,3) )                # 2x3 matrix filled with zeros\n",
+    "print(C)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "a9129600-f9b6-444b-8922-ed97bb4f5830",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[1. 1. 1.]\n",
+      " [1. 1. 1.]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "D = np.ones( (2,3) )                 # 2x3 matrix filled with ones\n",
+    "print(D)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a88f65a8-90b2-40f2-a708-94580a465b42",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "## Python \"oddities\" (very important!)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "947d24ca-18f9-4668-b45b-94758161c020",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0 2 3]\n"
+     ]
+    }
+   ],
+   "source": [
+    "a = np.array([1,2,3])   # a should be seen as a reference (pointer) to an array \n",
+    "b = a                   # \"pointer\" b is set to the value of pointer \"a\"\n",
+    "b[0] = 0.               # the vector pointed by b is modified\n",
+    "print(a)                # prints [0 2 3] (!)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "e92357c5-ce86-4bd4-a604-4d134b0a20f7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "c = a.copy()            # creates an independent copy of \"a\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bcee6b24-0d63-42ca-98c4-1adc224846bb",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "## Matrix/vector operations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "23946517-ab31-4c0d-8dad-9212b868e05e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "A = np.array([[1,2,3],\n",
+    "              [4,5,6]])\n",
+    "b = np.array([1,2])\n",
+    "c = np.array([3,4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "296aec76-2209-45a9-9727-5f25c0e4f517",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[4 6]\n"
+     ]
+    }
+   ],
+   "source": [
+    "d = b + c               # sum\n",
+    "print(d)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "2b0c4db5-fd7d-43a1-bd35-0800f2d273f9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[1 4]\n",
+      " [2 5]\n",
+      " [3 6]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "E = A.transpose()       # transpose of a matrix\n",
+    "print(E)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "dddf9979-ed72-466c-b50a-d9b369d36567",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[ 9 12 15]\n"
+     ]
+    }
+   ],
+   "source": [
+    "f = np.matmul(E, b)     # matrix multiplication\n",
+    "                        # (\"*\" is the element-wise operation as \".*\" in MATLAB)\n",
+    "print(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "1ab8f77a-9fc5-4f9b-aa22-2bf2237a3308",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[1 2]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "bt = b.reshape(1,2)     # column vector => line vector\n",
+    "print(bt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "0b6194b3-ac89-4d74-b548-fc705a055f79",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "16"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "d.dot(b)                # dot product"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f8ac0f5b-521e-424f-8434-998a6789efe4",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "## Slices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "9f6de2e2-fd97-420a-894d-715f33efaffb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[ 11 -12  13 -14]\n",
+      " [-21  22 -23  24]\n",
+      " [ 31  32  33  34]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "A = np.array([[ 11, -12, 13, -14 ],\n",
+    "              [ -21, 22, -23, 24 ],\n",
+    "              [ 31, 32, 33, 34 ]])\n",
+    "print(A)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "3cf5e680-94a4-409a-9373-f33218a0a9b9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-23"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A[1,2]\t                          # A(2,3) in MATLAB"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "9b7bf918-abb8-4b61-a4ec-b414ff6f74d8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 11, -12,  13, -14])"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A[0,]                             # A(1,:) in MATLAB (first row)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "8936a565-0c06-4bbf-b541-cb95847a4098",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 11, -21,  31])"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A[:,0]                            # A(:,1) in MATLAB (first column)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "1fca4996-0564-4ab1-9ddb-f355768b0d20",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-21,  22, -23,  24],\n",
+       "       [ 31,  32,  33,  34]])"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A[1:,]                            # A(2:end,:) in MATLAB (all, except first row)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "e79b4919-6cf2-4293-8186-33c5045044fa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-21,  22, -23,  24],\n",
+       "       [ 31,  32,  33,  34]])"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A[-2:,]                           # A(end-1:end,:) in MATLAB (last two rows)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ad66de2d-46bd-4555-8a53-f7ec604dcc60",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "## Linear algebra"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "a3310d19-6d05-4a2f-b22e-88834ac07994",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[  630 -1130   -90]\n",
+      " [-1130  2030   110]\n",
+      " [  -90   110  4230]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "B = np.matmul(A, A.transpose())   # square matrix\n",
+    "print(B)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "67b6a033-d84f-4ffd-9d1f-194341c280fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6767999.999999746"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.linalg.det(B)                  # determinant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "f5d071a3-d82c-43b6-9687-70f18159bdfc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[6.02701054e-01 2.64688850e+03 4.24250880e+03]\n"
+     ]
+    }
+   ],
+   "source": [
+    "(vals, vecs) = np.linalg.eig(B)   # eigenvalues / eigenvectors\n",
+    "print(vals)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "2e4d6341-6037-4d5a-8e61-01f197728b60",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[-0.87381107 -0.48389356 -0.04797116]\n",
+      " [-0.48622919  0.87069032  0.07402395]\n",
+      " [-0.00594831 -0.08800792  0.99610201]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(vecs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "0a08d7c4-ad05-4de2-a60a-328cb43f3337",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1.98037825 1.10212766 0.01371158]\n"
+     ]
+    }
+   ],
+   "source": [
+    "rhs = np.array([1,1,1])            \n",
+    "x = np.linalg.solve(B,rhs)        # solves [B]{x} = {rhs} \n",
+    "print(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "4758c366-1ae8-4455-b4c5-0a3f97820cc3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1. 1. 1.]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(B.dot(x))    # or np.matmul(B,x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35728504-5ebb-4a64-9b87-6f7d99bd764f",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "## Concatenation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "c47dc9c1-43cf-434d-b1e9-ab846606a8e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1 2 3 4]\n"
+     ]
+    }
+   ],
+   "source": [
+    "a = np.arange(1, 5)                   # a=1:4 in MATLAB\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "c30d6556-69d7-4dc5-9039-a9aa795e6421",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0 1 2 3 4 5]\n"
+     ]
+    }
+   ],
+   "source": [
+    "b = np.concatenate( ([0], a, [5]) )\n",
+    "print(b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "ccebba07-28d6-49ba-87fc-889b92fbd849",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[1 2 3 4]\n",
+      " [1 2 3 4]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "c = np.vstack( (a, a) )               # vertical stacking\n",
+    "print(c)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "3e7ff597-56e0-4cb8-8233-3fe78373115a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1 2 3 4 1 2 3 4]\n"
+     ]
+    }
+   ],
+   "source": [
+    "d = np.hstack( (a, a) )               # horizontal stacking\n",
+    "print(d)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e7a7fdd-d06c-4f90-92a9-21338f4ef480",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "## Basic plot example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "89183b94-2850-4daa-a452-c7ab3f400712",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "03823bda-9932-4e60-b036-21b55a2999a2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "x = np.linspace(0., 4*np.pi, 100)\n",
+    "f = np.sin(x)\n",
+    "g = np.cos(2*x) + 0.5*np.sin(4*x)\n",
+    "\n",
+    "fig = plt.figure()\n",
+    "plt.plot(x, f, 'b-', label='f(x)')\n",
+    "plt.plot(x, g, 'r-', label='g(x)')   # figure is \"held\" by default\n",
+    "plt.grid()\n",
+    "plt.legend()\n",
+    "plt.xlabel('x')\n",
+    "plt.ylabel('y')\n",
+    "plt.title(r\"$\\lambda=5$\")  # latex commands are ok (r means \"raw\" string)\n",
+    "\n",
+    "fig.savefig('fig.pdf')  # save your fig in a vector format (.pdf or .eps)\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "27e6e8e6-141e-414a-b520-b21b90f48ac7",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "## Improved plot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "72ca7562-882d-439c-bf74-44f0bd4b89db",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# additionnal options\n",
+    "plt.rcParams.update({'figure.autolayout': True})  # = plt.tight_layout()\n",
+    "plt.rcParams.update({'font.size': 14})  # increases default font size\n",
+    "\n",
+    "x = np.linspace(0., 4*np.pi, 100)\n",
+    "f = np.sin(x)\n",
+    "g = np.cos(2*x)+0.5*np.sin(4*x)\n",
+    "\n",
+    "fig = plt.figure()\n",
+    "plt.plot(x, f, 'b-', label='f(x)')\n",
+    "plt.plot(x, g, 'r-', label='g(x)')\n",
+    "plt.grid()\n",
+    "plt.legend(loc='upper center', ncol=2, fontsize='small')\n",
+    "plt.xlabel('x')\n",
+    "plt.ylabel('y')\n",
+    "plt.axhline(0.0, color='black')  # black x axis\n",
+    "plt.title(r\"$\\lambda=5$\")\n",
+    "yl1, yl2 = plt.ylim()\n",
+    "dy = yl2-yl1\n",
+    "plt.ylim(yl2-dy*1.1, yl1+dy*1.2)  # more space above curves\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b256ea83-5b4a-4f7e-a829-fc656efc9ee6",
+   "metadata": {},
+   "source": [
+    "## 3D plot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "31774ac4-efb6-4696-bacc-b2106ec041db",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib  \n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot(111, projection='3d')\n",
+    "\n",
+    "x = np.linspace(0, 2*np.pi, 20)\n",
+    "y = np.linspace(0, 2*np.pi, 20)\n",
+    "\n",
+    "X, Y = np.meshgrid(x, y)\n",
+    "Z = np.sin(X)+np.cos(Y)\n",
+    "\n",
+    "ax.plot_surface(X,Y,Z, cmap=matplotlib.cm.coolwarm)\n",
+    "\n",
+    "ax.set_xlabel(r'$x$')\n",
+    "ax.set_ylabel(r'$y$')\n",
+    "ax.set_zlabel(r'$z=\\sin(x)+\\cos(y)$')\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d52fbcb-0756-4d8b-b430-98cd02d7da77",
+   "metadata": {},
+   "source": [
+    "## Solving a sparse linear system"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "227f43af-4b18-4fd0-a2f8-a28139cb5b6a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/lib/python3/dist-packages/scipy/sparse/linalg/_dsolve/linsolve.py:206: MatrixRankWarning: Matrix is exactly singular\n",
+      "  warn(\"Matrix is exactly singular\", MatrixRankWarning)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import scipy.sparse\n",
+    "import scipy.sparse.linalg\n",
+    "\n",
+    "nnod = 10  # number of nodes\n",
+    "\n",
+    "# sparse matrix creation\n",
+    "Ai = []  # row indexes\n",
+    "Aj = []  # column indexes\n",
+    "Av = []  # values\n",
+    "f = np.zeros(nnod)  # system rhs\n",
+    "\n",
+    "# assembly\n",
+    "# ...fill Ai, Aj, Av lists with (i,j,v) values\n",
+    "# ...fill f with f[ni] += fe[i]\n",
+    "\n",
+    "# implementation has been deleted => this will produce an error \n",
+    "\n",
+    "# build CSR matrix from tuples (Ai, Aj, Av)\n",
+    "# note: values with same (i,j) are summed!\n",
+    "K = scipy.sparse.csr_matrix((Av, (Ai, Aj)), shape=(nnod, nnod))\n",
+    "\n",
+    "# solve system\n",
+    "u = scipy.sparse.linalg.spsolve(K, f)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d87061b-07e6-4067-b3dc-c43a6039c4b0",
+   "metadata": {},
+   "source": [
+    "see also [sparse matrices (scipy.org)](https://docs.scipy.org/doc/scipy/reference/sparse.html)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2cfb0327-9acc-47fd-a4f3-6ef1c78b8af7",
+   "metadata": {},
+   "source": [
+    "# Object-Oriented Programming (OOP)\n",
+    "\n",
+    "## A quick introduction\n",
+    "\n",
+    "Python is said to be **object-oriented**, as many modern programming languages, which means that you can create **your own types** of data beyond the basic types provided by the language (integers, floating-point numbers, strings, etc.).\n",
+    "\n",
+    "Learning to write good object-oriented code is not easy but it can be learnt **incrementally**. You may take advantage of this homework to get familiar with OOP and you may try to write your first objects (with our help).\n",
+    "\n",
+    "This opportunity to learn OOP was requested by the students from last years, although we never asked them to write object-oriented programs. Using OOP in your homework is **not mandatory**.\n",
+    "\n",
+    "Leaning OOP with python is much easier than learning it with compiled languages such as C++, Java, C#, etc.\n",
+    "\n",
+    "## Classes\n",
+    "\n",
+    "New types are defined in **classes**. \n",
+    "\n",
+    "A class gathers several variables which are used together. This is similar to a structure (`struct`) in C."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "55129318-41c7-489f-a1b9-5ed24a0588a9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Vec:\n",
+    "\t\"a class is a series of variables used together\"\n",
+    "\tdef __init__(self, x, y):\n",
+    "\t\t\"\"\" this function is called 'the constructor' of the class\n",
+    "\t\tit is called each time a new variable of the type Vec is created\n",
+    "\t\t\"\"\"\n",
+    "\t\tself.x = x  # 'self' refers to 'this object'\n",
+    "\t\tself.y = y  # stores y in the object"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "5382eb75-ecb4-4cf3-84f1-125577ec568e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n"
+     ]
+    }
+   ],
+   "source": [
+    "v = Vec(1, 2)  # creates an object of type Vec and calls Vec.__init__(v, 1, 2)\n",
+    "print(v.x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "5bbfa8d9-7346-4ca2-931c-36cb44e26a10",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.23606797749979\n"
+     ]
+    }
+   ],
+   "source": [
+    "norm = math.sqrt(v.x*v.x + v.y*v.y) # computes the norm\n",
+    "print(norm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c337e31c-e93b-41d9-a66a-4ce226ab3243",
+   "metadata": {},
+   "source": [
+    "A variable of type `Vec` is called an **instance** of the class or **object**.\n",
+    "\n",
+    "`self.x` and `self.y` are called **attributes** (or **variable members**).\n",
+    "\n",
+    "Classes are much richer than structures. You can define functions in classes. They are called **methods** (or **member functions**):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "80bbbbc7-ea4d-4e3a-bb0a-3bf13761a34f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Vec:\n",
+    "\t\"basic 2D vector class\"\n",
+    "\tdef __init__(self, x=0.0, y=0.0): # you can set default values for the args\n",
+    "\t\tself.x = x\n",
+    "\t\tself.y = y\n",
+    "\t\n",
+    "\tdef norm(self):\n",
+    "\t\t\"computes the norm of the vector\"\n",
+    "\t\treturn math.sqrt(self.x*self.x + self.y*self.y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "1f011953-2b43-4288-9577-a25436a34b8f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.23606797749979\n"
+     ]
+    }
+   ],
+   "source": [
+    "v = Vec(1, 2)\n",
+    "norm = v.norm()  # calls Vec.norm(self=v)\n",
+    "print(norm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57d87595-027c-4cc8-9b9f-03a300125166",
+   "metadata": {},
+   "source": [
+    "Advantage: the user of the class does not need to know how the components of the vector are stored in the object.\n",
+    "\n",
+    "Hiding implementation details is called **abstraction**.\n",
+    "\n",
+    "Imagine that the implementation of the `Vec` class changes:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "eeb062a6-5c90-456e-8350-5233bf633afe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Vec:\n",
+    "\t\"basic 2D vector class\"\n",
+    "\tdef __init__(self, x=0.0, y=0.0):\n",
+    "\t\tself.v = [x,y]              # <= use a list instead of 2 variables\n",
+    "\t\n",
+    "\tdef norm(self):\n",
+    "\t\t\"computes the norm of the vector\"\n",
+    "\t\treturn math.sqrt(self.v[0]*self.v[0] + self.v[1]*self.v[1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "19f0b159-a565-45ab-868c-96214b63fca0",
+   "metadata": {},
+   "source": [
+    "The code using the class does not need any modification. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "4ef7a604-80d4-4923-a909-8c208ab3315e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.23606797749979\n"
+     ]
+    }
+   ],
+   "source": [
+    "v = Vec(1, 2)\n",
+    "norm = v.norm()  # calls Vec.norm(self=v)\n",
+    "print(norm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8e12273-f82b-4e08-9b4e-c786d84c8f1b",
+   "metadata": {},
+   "source": [
+    "Gathering functions and variables into objects reduce the amount of global variables and functions of the code, leading to more **modularity**. \n",
+    "\n",
+    "Special functions can be added so that our new vector behaves as we could expect. \n",
+    "\n",
+    "For example we can add a method for the addition of 2 vectors:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "21ea1f1c-df08-472b-9e51-7a017ac63ccd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Vec:\n",
+    "\t\"basic 2D vector class\"\n",
+    "\tdef __init__(self, x=0.0, y=0.0):\n",
+    "\t\tself.x, self.y = x, y\n",
+    "\t\n",
+    "\tdef __add__(self, v):\n",
+    "\t\t\"computes self + v\"\n",
+    "\t\treturn Vec(self.x+v.x, self.y+v.y)\n",
+    "\t\n",
+    "\tdef __str__(self):\n",
+    "\t\t\"builds a string representation of self\"\n",
+    "\t\treturn f\"[{self.x},{self.y}]\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "2a132ac4-b220-4c1c-9830-31fa6057a7ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2,3]\n"
+     ]
+    }
+   ],
+   "source": [
+    "v1 = Vec(1, 2)\n",
+    "v2 = Vec(1, 1)\n",
+    "v3 = v1+v2      # calls v1.__add__(v2) and returns Vec(2,3)\n",
+    "print(v3)       # calls Vec.__str__(v3) and prints [2,3]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e2d35191-e76b-4eb5-aabb-6d3aa199fe25",
+   "metadata": {},
+   "source": [
+    "In OOP, this is called **operator overloading**.\n",
+    "\n",
+    "## Objects for Finite Elements?\n",
+    "\n",
+    "There are many ways to define \"objects\" in the frame of the implementation of the finite element method. **There is no unique or best choice.** \n",
+    "\n",
+    "Ideas of objects could come from mathematical concepts or words that are used in the statement of the exercise.\n",
+    "Possible objects:\n",
+    "- BoundaryValueProblem\n",
+    "- WeakForm\n",
+    "- ShapeFunction\n",
+    "- Node\n",
+    "- FiniteElement \n",
+    "- DirichletBC, NeumannBC\n",
+    "- LinearSolver\n",
+    "\n",
+    "The choice depends on the size of the simulation code, the number of features that should be implemented, the amount of time you want to invest in learning OOP.\n",
+    "\n",
+    "OOP is also closely related to **refactoring techniques**. Refactoring means \"improving the structure of the code without adding new features\".\n",
+    "\n",
+    "It means that you can start writing the first lines of your code with a very limited number of objects (or even no object at all). \n",
+    "\n",
+    "Then, as the number of lines increases, if you see that many functions act on the same set of variables, it is usually a good idea to \"refactor\" your program and create a class gathering these variables together.\n",
+    "\n",
+    "By doing this, you do not create classes that are unnecessary. Indeed, using too many classes can lead to unreadable code. This is a common problem while learning OOP (\"**do not make each byte an object**\").\n",
+    "\n",
+    "## Example \n",
+    "\n",
+    "Implementation of a basic finite element solver for the Helmholtz equation in 1D:\n",
+    "$$\n",
+    "\\frac{d^2u}{dx^2}+k^2u = 0\\qquad x\\in ]0,L[ \\text{ and } k\\in\\mathbb{R}\n",
+    "$$\n",
+    "with appropriate boundary conditions.\n",
+    "\n",
+    "The problem is solved by an object named `Solver` which contains the main parameters and a `solve()` function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "dc288d05-da4a-48b1-aedd-578342f873fa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Solver:\n",
+    "    def __init__(self, k, L, ne):\n",
+    "        self.k = k      # wave number\n",
+    "        self.L = L      # domain length\n",
+    "        self.ne = ne    # nb of finite elements\n",
+    "    def solve(self):\n",
+    "        \"do the FE calculations\"\n",
+    "        pass            # (implementation deleted)\n",
+    "    def display(self, figname):\n",
+    "        \"display results\"\n",
+    "        pass            # (implementation deleted)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3762385c-2e46-481e-9ebe-38d9885fb298",
+   "metadata": {},
+   "source": [
+    "In the `Solver` object, the mesh is stored as an array of `Nodes` and an array of `Elements`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "6d6358dd-0a31-446a-b064-55af134e09e2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Node:\n",
+    "    \"a Node is an index to global vectors (x, u, etc)\"\n",
+    "    def __init__(self, idx):\n",
+    "        self.idx = idx\n",
+    "\t\t\n",
+    "class Element:\n",
+    "    \"a 1D finite Element with linear shape functions\"\n",
+    "    def __init__(self, n1, n2):\n",
+    "        self.nodes = [n1, n2]\n",
+    "    def getM(self, x):\n",
+    "        \"compute the elemental mass matrix M\"\n",
+    "        x1, x2 = [x[n.idx] for n in self.nodes]\n",
+    "        # (implementation deleted)\n",
+    "    def getK(self, x):\n",
+    "        \"compute the elemental stiffness matrix K\"\n",
+    "        # (implementation deleted)\n",
+    "    def h(self, x):\n",
+    "        \"returns the length of the element\"\n",
+    "        return x[self.nodes[-1].idx] - x[self.nodes[0].idx]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "72074425-9a6c-434c-92a6-93511be0f556",
+   "metadata": {},
+   "source": [
+    "Once everything is implemented, the usage of these objects leads to a very self-explanatory code:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "05da87dd-4e06-4574-b314-7aac8a105ad3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def main():\n",
+    "\n",
+    "    k = 10   # wave number\n",
+    "    L = 1.   # length of the domain\n",
+    "\n",
+    "    # solve the problem for 2 given numbers of FEs\n",
+    "    solver = Solver(k, L, ne=20)\n",
+    "    solver.solve()\n",
+    "    solver.display('fem_ne20')\n",
+    "\n",
+    "    solver = Solver(k, L, ne=60)\n",
+    "    solver.solve()\n",
+    "    solver.display('fem_ne60')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "3e2bf0ae-81bd-4606-ab98-1f589bf92b06",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def convergence_study():\n",
+    "    \n",
+    "    hs = []\n",
+    "    errors = []\n",
+    "    for i in range(1, 6):\n",
+    "        solver = Solver(k, L, ne=10**i)\n",
+    "        solver.solve()\n",
+    "        print(f'h = {solver.h: <10}error = {solver.error}')\n",
+    "        hs.append(solver.h)\n",
+    "        errors.append(solver.error)\n",
+    "\n",
+    "    f = plt.figure()\n",
+    "    plt.loglog(hs, errors, 'o-')\n",
+    "    #...\n",
+    "    f.show()\n",
+    "    plt.savefig(f'fig_error.svg')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "83fbb567-b4e7-4dd4-a445-e9911aa195e1",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "Note that the same level of clarity could be easily obtained with well-defined functions in a traditional functional-programming approach!\n",
+    "\n",
+    "## Final remarks on Object-Oriented Programming\n",
+    "- Once again: using objects is **not mandatory** for the project. Use classical functional programming (as you already did in C or any other language) if you are new to Python and/or finite elements.\n",
+    "- Keep in mind that using objects is **usually not recommended for such small programs** unless you want to \"play\" with objects and learn how OOP works in the frame of python.\n",
+    "- This introduction lacks one of the most interesting feature of OOP: **polymorphism**. It allows you to define derived types of data (by **inheritance**) and to manipulate their instances without knowing their exact types. "
+   ]
+  }
+ ],
+ "metadata": {
+  "authors": [
+   {
+    "name": "R. Boman"
+   },
+   {
+    "name": "M. Arnst"
+   }
+  ],
+  "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.11"
+  },
+  "title": "MATH0024 - Practical Hints for your Homeworks"
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f23634b230d10ca052228f540a954a39de91ab80
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,3 @@
+numpy
+scipy
+matplotlib