diff --git a/content/Week_2_2/PA_2_2_love_is_sparse.ipynb b/content/Week_2_2/PA_2_2_love_is_sparse.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..029f0871e1ed828a0c53526bd9b431a366f6af95
--- /dev/null
+++ b/content/Week_2_2/PA_2_2_love_is_sparse.ipynb
@@ -0,0 +1,477 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "c96d6259-08d6-4289-aea2-589d67cdb5ee",
+ "metadata": {},
+ "source": [
+ "# PA 2.2: Love is Sparse\n",
+ "\n",
+ "<h1 style=\"position: absolute; display: flex; flex-grow: 0; flex-shrink: 0; flex-direction: row-reverse; top: 60px;right: 30px; margin: 0; border: 0\">\n",
+ " <style>\n",
+ " .markdown {width:100%; position: relative}\n",
+ " article { position: relative }\n",
+ " </style>\n",
+ " <img src=\"https://gitlab.tudelft.nl/mude/public/-/raw/main/tu-logo/TU_P1_full-color.png\" style=\"width:100px\" />\n",
+ " <img src=\"https://gitlab.tudelft.nl/mude/public/-/raw/main/mude-logo/MUDE_Logo-small.png\" style=\"width:100px\" />\n",
+ "</h1>\n",
+ "<h2 style=\"height: 10px\">\n",
+ "</h2>\n",
+ "\n",
+ "*[CEGM1000 MUDE](http://mude.citg.tudelft.nl/): Week 2.2 Due: complete this PA prior to class on Friday, Nov 22, 2024.*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a28e541-d2d0-48a9-abf6-7b73075c8fd3",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "## Overview\n",
+ "\n",
+ "This assignment will introduce you to the concept of sparse matrices in Python and how they can be useful to speed up computations and reduce file sizes. To this end, we will be using the `scipy.sparse` library.\n",
+ "\n",
+ "**You will pass this assignment as long as your respository fulfills the following criteria:** \n",
+ "\n",
+ "- You have completed this notebook and it runs without errors\n",
+ "\n",
+ "## Reading\n",
+ "\n",
+ "Keep the `scipy.sparse` [documentation](https://docs.scipy.org/doc/scipy/reference/sparse.html) handy. Some of the work you'll do is based off this [blog](https://www.sefidian.com/2021/04/28/python-scipy-sparse-matrices-explained/), so you may find it helpful. In addition, if you don't know what a byte is, you may want to read up on [Wikipdia here](https://en.wikipedia.org/wiki/Byte) (not all of it, as long as you recognize that it is a measure of storage space on a computer).The concepts you learn here are applied to the Finite Element Method in this [book chapter UPDATE LINK](https://mude.citg.tudelft.nl/book/fem/matrix.html), which you are expected to read during Week 2.2.\n",
+ "\n",
+ "**Note:** you probably skipped over all the links in the paragraph above. While we forgive you for your haste, just remember to revisit some of them if you are struggling to finish the questions below!\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "a262eac1",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import scipy.sparse as sparse\n",
+ "import matplotlib.pyplot as plt\n",
+ "import timeit"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c3cd5017-10e0-4b64-ad1a-b626d80a128a",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "## Task 1: Why sparse?\n",
+ "\n",
+ "Some matrices have a lot of zeros, with such an example given below. When this is the case, the way we store the actual information of the matrix (the non-zero elements) can have a big impact on computation speed and storage demands. Formats which handle this by only storing non-zero elements are called sparse, and have very different internal representations of the data to the matrices you have been familiarized with in previous programming assignments.\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f583dfa0-5a21-4ebb-99e5-7b27b323171d",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
+ "<p>\n",
+ "<b>Task 1.1:</b> \n",
+ " \n",
+ "- Create a function (`create_dense`) which returns a square matrix of arbitrary size. \n",
+ "- The function will take as input the size N (such that the matrix is N x N) and one float between 0 and 1, which represents the approximate fraction of the elements of the matrix which are non-zero (it doesn't have to be super accurate).\n",
+ " \n",
+ "For now it just return a regular Numpy matrix. To do this, you can use <a href=\"https://numpy.org/doc/stable/reference/random/generated/numpy.random.rand.html\">numpy.random.rand</a> to create a random set of values between 0 and 1 and then threshold the entries with a simple boolean operator.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1310dca9-dc46-4ab1-ab78-0a5389191cfc",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "# SOLUTION (a few things will be removed)\n",
+ "def create_dense(size: int, percentage: float) -> np.array:\n",
+ " matrix = YOUR_CODE_HERE\n",
+ " matrix[YOUR_CODE_HERE] = 0\n",
+ " return matrix\n",
+ "####"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d670f274-ef24-4abd-86bf-3cd24e3cf5c5",
+ "metadata": {},
+ "source": [
+ "Now, set up a test to check if you set the function up correctly:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8f6a3117",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "test_size = YOUR_CODE_HERE\n",
+ "test_percentage = YOUR_CODE_HERE\n",
+ "matrix = create_dense(test_size, test_percentage)\n",
+ "assert np.count_nonzero(matrix) < test_percentage*1.1*test_size**2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0f3d9c79",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
+ "<p>\n",
+ "<b>Task 1.2:</b> \n",
+ "Use <a href=\"https://numpy.org/doc/stable/reference/generated/numpy.ndarray.nbytes.html\">array.nbytes</a> to find out how much space a 1000x1000 matrix with 10% non-zero elements takes. Try to explain where this number came from! (Hint: the answer is in the assert statement)\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "aa5a25f9",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "my_matrix_size = YOUR_CODE_HERE\n",
+ "assert my_matrix_size == 8*test_size**2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "912215f3",
+ "metadata": {},
+ "source": [
+ "Next we will explore how to use `scipy.sparse`, and how this reduces the data size of the matrix. The [ documentation](https://docs.scipy.org/doc/scipy/reference/sparse.html) gives us many different types of formats to choose from, so we'll explore two of them: BSR (Block Sparse Row) and CSR (Compressed Sparse Row). "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "25a832c8",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
+ "<p>\n",
+ "<b>Task 1.3:</b> \n",
+ " Complete the code below to make a CSR and BSR matrix from the <code>matrix</code> variable.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "29c0d2dc",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "csr_matrix = YOUR_CODE_HERE\n",
+ "bsr_matrix = YOUR_CODE_HERE"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "56334ed7",
+ "metadata": {},
+ "source": [
+ "Let's compare the new storage requirements and see how much of an improvement we got (it should approach the value used above for `test_percentage`, but not reach it exactly):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "a46df127",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CSR matrix size: 100418 bytes\n",
+ "Compared to the normal matrix, CSR uses this fraction of space: 0.100\n",
+ "BSR matrix size: 100418 bytes\n",
+ "Compared to the normal matrix, BSR uses this fraction of space: 0.100\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(f\"CSR matrix size: {csr_matrix.data.size} bytes\")\n",
+ "print(f\"Compared to the normal matrix, CSR uses this fraction of space: {csr_matrix.data.nbytes/my_matrix_size:0.3f}\")\n",
+ "print(f\"BSR matrix size: {bsr_matrix.data.size} bytes\")\n",
+ "print(f\"Compared to the normal matrix, BSR uses this fraction of space: {bsr_matrix.data.nbytes/my_matrix_size:0.3f}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cea28aa8",
+ "metadata": {},
+ "source": [
+ "## Task 2: [What is love?](https://www.youtube.com/watch?v=HEXWRTEbj1I)\n",
+ "\n",
+ "Let's look into a small example of how sparse matrices can also help improve calculation speeds. We'll study the mysterious case of a massive friend group with a concerning love circle and how we can predict how each person feels."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f832b8e0",
+ "metadata": {},
+ "source": [
+ "We know there is a certain pecking order in this group, and neighbours in this order have a love-hate relationship which can be quantified with a simple differential equation:\n",
+ "\n",
+ "$$\n",
+ "\\begin{pmatrix}\n",
+ "\\cfrac{dn_1}{dt}\\\\\n",
+ "\\cfrac{dn_2}{dt} \\\\\n",
+ "\\end{pmatrix} \n",
+ "=\n",
+ "\\begin{pmatrix}\n",
+ "0 & 1\\\\\n",
+ "-1 & 0 \\\\\n",
+ "\\end{pmatrix} \n",
+ "\\begin{pmatrix}\n",
+ "n_1\\\\\n",
+ "n_2 \\\\\n",
+ "\\end{pmatrix} \n",
+ "$$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b9d037e",
+ "metadata": {},
+ "source": [
+ "The state of any given person indicates how much they love the group in general. So in this case, person 2 doesn't like it when person 1 is happy. If we extend this to a four case scenario we'd get the following matrix:\n",
+ "$$\n",
+ "\\begin{pmatrix}\n",
+ "\\cfrac{dn_1}{dt}\\\\\n",
+ "\\cfrac{dn_2}{dt}\\\\\n",
+ "\\cfrac{dn_3}{dt}\\\\\n",
+ "\\cfrac{dn_4}{dt}\\\\\n",
+ "\\end{pmatrix} \n",
+ "=\n",
+ "\\begin{pmatrix}\n",
+ "0 & 1 & 0 & -1 \\\\\n",
+ "-1 & 0 & 1 & 0 \\\\\n",
+ "0 & -1 & 0 & 1 \\\\\n",
+ "1 & 0 & -1 & 0 \\\\\n",
+ "\\end{pmatrix} \n",
+ "\\begin{pmatrix}\n",
+ "n_1 \\\\\n",
+ "n_2 \\\\\n",
+ "n_3 \\\\\n",
+ "n_4 \\\\\n",
+ "\\end{pmatrix} \n",
+ "$$\n",
+ "\n",
+ "What happens if we extend it to even more people?\n",
+ "\n",
+ "Coincidentally this is very similar to how we use individual elements in the Finite Element Method! We can easily operationalize it using the method `ix_`, for which a simple example is provided in the code cell below (this example is generic to illustrate `ix_` usage and is not related to the love circle!):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "77f295f5",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[0. 0. 0.5 0. ]\n",
+ " [0. 1. 0.5 0. ]\n",
+ " [0. 0. 0.5 0. ]\n",
+ " [0. 1. 0.5 0. ]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "blank = np.zeros(shape=(4, 4))\n",
+ "blueprint = np.array([[0, 0.5], \n",
+ " [1, 0.5]])\n",
+ "\n",
+ "for i in range(2):\n",
+ " # First argument will be used for rows\n",
+ " # Second for columns\n",
+ " blank[np.ix_([i*2, i*2 + 1], [1, 2])] = blueprint\n",
+ " \n",
+ "print(blank)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a73f37b-6763-4d1c-92b8-994aa28f8ff6",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
+ "<p>\n",
+ "<b>Task 2.1:</b> \n",
+ " Generate the matrix <code>relationship</code> for the differential equation for 1000 people. Use the <a href=\"https://numpy.org/doc/stable/reference/generated/numpy.ix_.html\"><code>numpy.ix_</code></a> function to make your life easier. \n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b622c84f",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "N = 1000\n",
+ "relationship = np.zeros(shape=(N, N))\n",
+ "\n",
+ "YOUR_CODE_HERE"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "526706d5",
+ "metadata": {},
+ "source": [
+ "Finally, we are going to use the forward Euler method to simulate this differential equation for a total of 5 seconds over 1000 iterations. This has already been implemented in the `test` method."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9f128b80",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
+ "<p>\n",
+ "<b>Task 2.2:</b> \n",
+ " Find the time it takes to evaluate the relationship using <code>timeit</code> by entering the function you wish to evaluate as a string. HINT: you have already learned how to convert a matrix into a sparse format, and the function is defined for you. Run the code cell and compare the performances of the different matrix formats. Which one is faster? How much space do they take?\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0a8f83b9",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Standard: 0.3432\n",
+ "CSR: 0.0091\n",
+ "BSR: 0.0085\n"
+ ]
+ }
+ ],
+ "source": [
+ "N_ITS = 1000\n",
+ "T = 5 # Seconds\n",
+ "dt = T/N_ITS\n",
+ "\n",
+ "def test(rel_matrix):\n",
+ " state = np.zeros(N); state[0] = 1\n",
+ " for i in range(N_ITS):\n",
+ " state = state + rel_matrix @ state * dt\n",
+ "\n",
+ "# SOLUTION (only the strings in timeit will be removed + matrix definitions)\n",
+ "csr_matrix = YOUR_CODE_HERE\n",
+ "bsr_matrix = YOUR_CODE_HERE\n",
+ "print(f\"Standard: {timeit.timeit('test(relationship)', globals=globals(), number=10)/10:.4f}\")\n",
+ "print(f\"CSR: {timeit.timeit('test(csr_matrix)', globals=globals(), number=10)/10:.4f}\")\n",
+ "print(f\"BSR: {timeit.timeit('test(bsr_matrix)', globals=globals(), number=10)/10:.4f}\")\n",
+ "########\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "920bab21",
+ "metadata": {},
+ "source": [
+ "One final consideration when using sparse matrices is that it can take a long time to generate them from a regular matrix. You can test this out by placing the matrix generation inside or outside the <code>timeit</code> code to compare their performances."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "80580ab9-4d79-46b1-ae6e-775af04d43ad",
+ "metadata": {},
+ "source": [
+ "**End of notebook.**\n",
+ "<h2 style=\"height: 60px\">\n",
+ "</h2>\n",
+ "<h3 style=\"position: absolute; display: flex; flex-grow: 0; flex-shrink: 0; flex-direction: row-reverse; bottom: 60px; right: 50px; margin: 0; border: 0\">\n",
+ " <style>\n",
+ " .markdown {width:100%; position: relative}\n",
+ " article { position: relative }\n",
+ " </style>\n",
+ " <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc-sa/4.0/\">\n",
+ " <img alt=\"Creative Commons License\" style=\"border-width:; width:88px; height:auto; padding-top:10px\" src=\"https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png\" />\n",
+ " </a>\n",
+ " <a rel=\"TU Delft\" href=\"https://www.tudelft.nl/en/ceg\">\n",
+ " <img alt=\"TU Delft\" style=\"border-width:0; width:100px; height:auto; padding-bottom:0px\" src=\"https://gitlab.tudelft.nl/mude/public/-/raw/main/tu-logo/TU_P1_full-color.png\"/>\n",
+ " </a>\n",
+ " <a rel=\"MUDE\" href=\"http://mude.citg.tudelft.nl/\">\n",
+ " <img alt=\"MUDE\" style=\"border-width:0; width:100px; height:auto; padding-bottom:0px\" src=\"https://gitlab.tudelft.nl/mude/public/-/raw/main/mude-logo/MUDE_Logo-small.png\"/>\n",
+ " </a>\n",
+ " \n",
+ "</h3>\n",
+ "<span style=\"font-size: 75%\">\n",
+ "© Copyright 2023 <a rel=\"MUDE Team\" href=\"https://studiegids.tudelft.nl/a101_displayCourse.do?course_id=65595\">MUDE Teaching Team</a> TU Delft. This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc-sa/4.0/\">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "mude-base",
+ "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.12.5"
+ },
+ "widgets": {
+ "application/vnd.jupyter.widget-state+json": {
+ "state": {},
+ "version_major": 2,
+ "version_minor": 0
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/content/Week_2_2/PA_2_2_solution.ipynb b/content/Week_2_2/PA_2_2_solution.ipynb
index 9b385f812e7e25a9fe064ad37ae6898ddea29e81..70c7aacb4393661c417f26ffe7b1a3fbaac10f77 100644
--- a/content/Week_2_2/PA_2_2_solution.ipynb
+++ b/content/Week_2_2/PA_2_2_solution.ipynb
@@ -5,7 +5,7 @@
"id": "c96d6259-08d6-4289-aea2-589d67cdb5ee",
"metadata": {},
"source": [
- "# PA 2.2: Love Is Sparse\n",
+ "# PA 2.2: Love is Sparse\n",
"\n",
"<h1 style=\"position: absolute; display: flex; flex-grow: 0; flex-shrink: 0; flex-direction: row-reverse; top: 60px;right: 30px; margin: 0; border: 0\">\n",
" <style>\n",
@@ -18,7 +18,7 @@
"<h2 style=\"height: 10px\">\n",
"</h2>\n",
"\n",
- "*[CEGM1000 MUDE](http://mude.citg.tudelft.nl/): Week 2.2. Due: complete this PA prior to class on Friday, Nov 22, 2024.*"
+ "*[CEGM1000 MUDE](http://mude.citg.tudelft.nl/): Week 2.2 Due: complete this PA prior to class on Friday, Nov 22, 2024.*"
]
},
{
@@ -28,21 +28,19 @@
"tags": []
},
"source": [
- "## Overview of Assignment\n",
+ "## Overview\n",
"\n",
"This assignment will introduce you to the concept of sparse matrices in Python and how they can be useful to speed up computations and reduce file sizes. To this end, we will be using the `scipy.sparse` library.\n",
"\n",
- "## Reading\n",
+ "**You will pass this assignment as long as your respository fulfills the following criteria:** \n",
"\n",
- "Keep the `scipy.sparse` [documentation](https://docs.scipy.org/doc/scipy/reference/sparse.html) handy. Some of the work you'll do is based off this [blog](https://www.sefidian.com/2021/04/28/python-scipy-sparse-matrices-explained/), so you may find it helpful. In addition, if you don't know what a byte is, you may want to read up on [Wikipdia here](https://en.wikipedia.org/wiki/Byte) (not all of it, as long as you recognize that it is a measure of storage space on a computer).The concepts you learn here are applied to the Finite Element Method in this [book chapter](https://mude.citg.tudelft.nl/book/fem/matrix.html), which you are expected to read during Week 2.2.\n",
+ "- You have completed this notebook and it runs without errors\n",
"\n",
- "**Note:** you probably skipped over all the links in the paragraph above. While we forgive you for your haste, just remember to revisit some of them if you are struggling to finish the questions below!\n",
+ "## Reading\n",
"\n",
- "## Assignment Criteria\n",
+ "Keep the `scipy.sparse` [documentation](https://docs.scipy.org/doc/scipy/reference/sparse.html) handy. Some of the work you'll do is based off this [blog](https://www.sefidian.com/2021/04/28/python-scipy-sparse-matrices-explained/), so you may find it helpful. In addition, if you don't know what a byte is, you may want to read up on [Wikipdia here](https://en.wikipedia.org/wiki/Byte) (not all of it, as long as you recognize that it is a measure of storage space on a computer).The concepts you learn here are applied to the Finite Element Method in this [book chapter UPDATE LINK](https://mude.citg.tudelft.nl/book/fem/matrix.html), which you are expected to read during Week 2.2.\n",
"\n",
- "**You will pass this assignment as long as your respository fulfills the following criteria:** \n",
- "\n",
- "- You have completed this notebook and it runs without errors"
+ "**Note:** you probably skipped over all the links in the paragraph above. While we forgive you for your haste, just remember to revisit some of them if you are struggling to finish the questions below!\n"
]
},
{
@@ -81,7 +79,7 @@
"source": [
"<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
"<p>\n",
- "<b>Task 1:</b> \n",
+ "<b>Task 1.1:</b> \n",
" \n",
"- Create a function (`create_dense`) which returns a square matrix of arbitrary size. \n",
"- The function will take as input the size N (such that the matrix is N x N) and one float between 0 and 1, which represents the approximate fraction of the elements of the matrix which are non-zero (it doesn't have to be super accurate).\n",
@@ -113,7 +111,7 @@
"id": "d670f274-ef24-4abd-86bf-3cd24e3cf5c5",
"metadata": {},
"source": [
- "Now we will test that you set it up correctly:"
+ "Now, set up a test to check if you set the function up correctly:"
]
},
{
@@ -131,14 +129,6 @@
"assert np.count_nonzero(matrix) < test_percentage*1.1*test_size**2"
]
},
- {
- "cell_type": "markdown",
- "id": "bd6ca065-f05f-4c27-bfde-1ea77893342d",
- "metadata": {},
- "source": [
- "One of the reasons we are interested in sparse matrices"
- ]
- },
{
"cell_type": "markdown",
"id": "0f3d9c79",
@@ -146,7 +136,7 @@
"source": [
"<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
"<p>\n",
- "<b>Task 2:</b> \n",
+ "<b>Task 1.2:</b> \n",
"Use <a href=\"https://numpy.org/doc/stable/reference/generated/numpy.ndarray.nbytes.html\">array.nbytes</a> to find out how much space a 1000x1000 matrix with 10% non-zero elements takes. Try to explain where this number came from! (Hint: the answer is in the assert statement)\n",
"</p>\n",
"</div>"
@@ -181,7 +171,7 @@
"source": [
"<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
"<p>\n",
- "<b>Task 3:</b> \n",
+ "<b>Task 1.3:</b> \n",
" Complete the code below to make a CSR and BSR matrix from the <code>matrix</code> variable.\n",
"</p>\n",
"</div>"
@@ -221,10 +211,10 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "CSR matrix size: 500688 bytes\n",
- "Compared to the normal matrix, CSR uses this fraction of space: 0.501\n",
- "BSR matrix size: 500688 bytes\n",
- "Compared to the normal matrix, BSR uses this fraction of space: 0.501\n"
+ "CSR matrix size: 100418 bytes\n",
+ "Compared to the normal matrix, CSR uses this fraction of space: 0.100\n",
+ "BSR matrix size: 100418 bytes\n",
+ "Compared to the normal matrix, BSR uses this fraction of space: 0.100\n"
]
}
],
@@ -254,8 +244,8 @@
"\n",
"$$\n",
"\\begin{pmatrix}\n",
- "\\frac{dn_1}{dt}\\\\\n",
- "\\frac{dn_2}{dt} \\\\\n",
+ "\\cfrac{dn_1}{dt}\\\\\n",
+ "\\cfrac{dn_2}{dt} \\\\\n",
"\\end{pmatrix} \n",
"=\n",
"\\begin{pmatrix}\n",
@@ -277,10 +267,10 @@
"The state of any given person indicates how much they love the group in general. So in this case, person 2 doesn't like it when person 1 is happy. If we extend this to a four case scenario we'd get the following matrix:\n",
"$$\n",
"\\begin{pmatrix}\n",
- "\\frac{dn_1}{dt}\\\\\n",
- "\\frac{dn_2}{dt}\\\\\n",
- "\\frac{dn_3}{dt}\\\\\n",
- "\\frac{dn_4}{dt}\\\\\n",
+ "\\cfrac{dn_1}{dt}\\\\\n",
+ "\\cfrac{dn_2}{dt}\\\\\n",
+ "\\cfrac{dn_3}{dt}\\\\\n",
+ "\\cfrac{dn_4}{dt}\\\\\n",
"\\end{pmatrix} \n",
"=\n",
"\\begin{pmatrix}\n",
@@ -304,7 +294,7 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 8,
"id": "77f295f5",
"metadata": {
"tags": []
@@ -341,7 +331,7 @@
"source": [
"<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
"<p>\n",
- "<b>Task 4:</b> \n",
+ "<b>Task 2.1:</b> \n",
" Generate the matrix <code>relationship</code> for the differential equation for 1000 people. Use the <a href=\"https://numpy.org/doc/stable/reference/generated/numpy.ix_.html\"><code>numpy.ix_</code></a> function to make your life easier. \n",
"</p>\n",
"</div>"
@@ -349,7 +339,7 @@
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": 9,
"id": "b622c84f",
"metadata": {
"tags": []
@@ -382,7 +372,7 @@
"source": [
"<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
"<p>\n",
- "<b>Task 5:</b> \n",
+ "<b>Task 2.2:</b> \n",
" Find the time it takes to evaluate the relationship using <code>timeit</code> by entering the function you wish to evaluate as a string. HINT: you have already learned how to convert a matrix into a sparse format, and the function is defined for you. Run the code cell and compare the performances of the different matrix formats. Which one is faster? How much space do they take?\n",
"</p>\n",
"</div>"
@@ -390,7 +380,7 @@
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": 10,
"id": "0a8f83b9",
"metadata": {
"tags": []
@@ -400,9 +390,9 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Standard: 0.1808\n",
- "CSR: 0.0187\n",
- "BSR: 0.0270\n"
+ "Standard: 0.3432\n",
+ "CSR: 0.0091\n",
+ "BSR: 0.0085\n"
]
}
],
@@ -431,7 +421,7 @@
"id": "920bab21",
"metadata": {},
"source": [
- "One final consideration when using sparse matrices is that it can take a long time to generate them from a regular matrix. You can test this out by placing the matrix generation inside or outside the timeit code to compare their performances."
+ "One final consideration when using sparse matrices is that it can take a long time to generate them from a regular matrix. You can test this out by placing the matrix generation inside or outside the <code>timeit</code> code to compare their performances."
]
},
{
@@ -465,7 +455,7 @@
],
"metadata": {
"kernelspec": {
- "display_name": "Python 3 (ipykernel)",
+ "display_name": "mude-base",
"language": "python",
"name": "python3"
},
@@ -479,7 +469,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.11.4"
+ "version": "3.12.5"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
diff --git a/content/Week_2_2/WS_2_2_more_support.ipynb b/content/Week_2_2/WS_2_2_more_support.ipynb
index 56c035698fedac6a4f0d0432ddfafc8fd8731aba..d8c9fb56ad1c4c0f17f23b9431de2f162d93fa78 100644
--- a/content/Week_2_2/WS_2_2_more_support.ipynb
+++ b/content/Week_2_2/WS_2_2_more_support.ipynb
@@ -2,7 +2,7 @@
"cells": [
{
"cell_type": "markdown",
- "id": "1b37faf2",
+ "id": "e9d1ff8c",
"metadata": {},
"source": [
"# WS 2.2: More support\n",
@@ -23,12 +23,12 @@
},
{
"cell_type": "markdown",
- "id": "d7378715-48ab-461f-ab06-2ad980e7f987",
+ "id": "576445ba-cfe4-4c22-acbf-5d5fc6d0da1c",
"metadata": {},
"source": [
"In the book, the finite element derivation and implementation of rod extension (the 1D Poisson equation) is presented. In this workshop, you are asked to do the same for a slightly different problem.\n",
"\n",
- "## A modification to the PDE: continuous elastic support\n",
+ "## Part 1: A modification to the PDE: continuous elastic support\n",
"\n",
"<p align=\"center\">\n",
"<img src=\"https://raw.githubusercontent.com/fmeer/public-files/main/barDefinition-2.png\" width=\"400\"/>\n",
@@ -61,7 +61,7 @@
"tags": []
},
"source": [
- "<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
"<p>\n",
"<b>Task 1: Derive the discrete form</b> \n",
"\n",
@@ -72,7 +72,7 @@
},
{
"cell_type": "markdown",
- "id": "45074810-ef2e-4976-aed4-732b082ef025",
+ "id": "f4805906",
"metadata": {},
"source": [
"***Your derivation here***"
@@ -83,7 +83,7 @@
"id": "6240afb2-28a3-49c4-b3d2-fb53ea110b99",
"metadata": {},
"source": [
- "## Modification to the FE implementation\n",
+ "## Part 2: Modification to the FE implementation\n",
"\n",
"The only change with respect to the procedure as implemented in the book is the formulation of the $\\mathbf{K}$-matrix, which now consists of two terms:\n",
"\n",
@@ -96,7 +96,7 @@
},
{
"cell_type": "markdown",
- "id": "eac28a06",
+ "id": "f247cc75-caa2-47b7-8fe8-80f8521f7d8c",
"metadata": {},
"source": [
"<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
@@ -126,7 +126,7 @@
},
{
"cell_type": "code",
- "execution_count": 1,
+ "execution_count": null,
"id": "retired-cartoon",
"metadata": {},
"outputs": [],
@@ -136,7 +136,7 @@
},
{
"cell_type": "markdown",
- "id": "303429de",
+ "id": "20bcac74-1918-4c5e-bd17-148829c7ef8f",
"metadata": {},
"source": [
"<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
@@ -146,15 +146,16 @@
"<b>Task 3: Investigate the influence of discretization on the quality of the solution</b>\n",
"\n",
"- How many elements do you need to get a good solution?\n",
- "- How about when the stiffness of the distributed support is increased to $k=10^6$ N/$m^2$\n",
+ "- How about when the stiffness of the distributed support is increased to $k=10^6$ N/$m^2$ ?\n",
"</p>\n",
"\n",
+ "Simulate and plot different cases for each of the above questions.\n",
"</div>"
]
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": null,
"id": "e35e64ac-5e72-4575-bbb1-371fa524a747",
"metadata": {},
"outputs": [],
@@ -162,9 +163,19 @@
"# YOUR_CODE_HERE"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "936a7ebd-262b-457c-9c3f-8ab3196b7c26",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# YOUR_CODE_HERE"
+ ]
+ },
{
"cell_type": "markdown",
- "id": "d9665a79",
+ "id": "7ac81786",
"metadata": {},
"source": [
"**End of notebook.**\n",
@@ -207,7 +218,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.11.4"
+ "version": "3.10.12"
},
"latex_envs": {
"LaTeX_envs_menu_present": true,
diff --git a/content/Week_2_2/PA_2_1_solution.ipynb b/content/Week_2_2/old/PA_2_1_solution.ipynb
similarity index 100%
rename from content/Week_2_2/PA_2_1_solution.ipynb
rename to content/Week_2_2/old/PA_2_1_solution.ipynb
diff --git a/content/Week_2_2/PA_2_1_solution_sympy.ipynb b/content/Week_2_2/old/PA_2_1_solution_sympy.ipynb
similarity index 100%
rename from content/Week_2_2/PA_2_1_solution_sympy.ipynb
rename to content/Week_2_2/old/PA_2_1_solution_sympy.ipynb
diff --git a/content/Week_2_2/old/WS_2_2_more_support.ipynb b/content/Week_2_2/old/WS_2_2_more_support.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..56c035698fedac6a4f0d0432ddfafc8fd8731aba
--- /dev/null
+++ b/content/Week_2_2/old/WS_2_2_more_support.ipynb
@@ -0,0 +1,240 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "1b37faf2",
+ "metadata": {},
+ "source": [
+ "# WS 2.2: More support\n",
+ "\n",
+ "<h1 style=\"position: absolute; display: flex; flex-grow: 0; flex-shrink: 0; flex-direction: row-reverse; top: 60px;right: 30px; margin: 0; border: 0\">\n",
+ " <style>\n",
+ " .markdown {width:100%; position: relative}\n",
+ " article { position: relative }\n",
+ " </style>\n",
+ " <img src=\"https://gitlab.tudelft.nl/mude/public/-/raw/main/tu-logo/TU_P1_full-color.png\" style=\"width:100px\" />\n",
+ " <img src=\"https://gitlab.tudelft.nl/mude/public/-/raw/main/mude-logo/MUDE_Logo-small.png\" style=\"width:100px\" />\n",
+ "</h1>\n",
+ "<h2 style=\"height: 10px\">\n",
+ "</h2>\n",
+ "\n",
+ "*[CEGM1000 MUDE](http://mude.citg.tudelft.nl/): Week 2.2. For: 20 November, 2024*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d7378715-48ab-461f-ab06-2ad980e7f987",
+ "metadata": {},
+ "source": [
+ "In the book, the finite element derivation and implementation of rod extension (the 1D Poisson equation) is presented. In this workshop, you are asked to do the same for a slightly different problem.\n",
+ "\n",
+ "## A modification to the PDE: continuous elastic support\n",
+ "\n",
+ "<p align=\"center\">\n",
+ "<img src=\"https://raw.githubusercontent.com/fmeer/public-files/main/barDefinition-2.png\" width=\"400\"/>\n",
+ "</p>\n",
+ "\n",
+ "For this exercise we still consider a 1D rod. However, now the rod is elastically supported. An example of this would be a foundation pile in soil. \n",
+ "\n",
+ "The problem of an elastically supported rod can be described with the following differential equation:\n",
+ "\n",
+ "$$ -EA \\frac{\\partial^2 u}{\\partial x^2} + ku = f $$\n",
+ "\n",
+ "with:\n",
+ "\n",
+ "$$\n",
+ "u = 0, \\quad \\text{at} \\quad x = 0 \\\\\n",
+ "EA\\frac{\\partial u}{{\\partial x}} = F, \\quad \\text{at} \\quad x = L\n",
+ "$$\n",
+ "\n",
+ "This differential equation is the inhomogeneous Helmholtz equation, which also has applications in dynamics and electromagnetics. The additional term with respect to the case without elastic support is the second term on the left hand side: $ku$. \n",
+ "\n",
+ "The finite element discretized version of this PDE can be obtained following the same steps as shown for the unsupported rod in the book. Note that there are no derivatives in the $ku$ which means that integration by parts does not need to be applied on this term. Using Neumann boundary condition (i.e. an applied load) at $x=L$ and a constant distributed load $f(x)=q$, the following expression is found for the discretized form:\n",
+ "\n",
+ "$$\\left[\\int \\mathbf{B}^T EA \\mathbf{B} + \\mathbf{N}^T k \\mathbf{N} \\,dx\\right]\\mathbf{u} = \\int \\mathbf{N}^T q \\,d x + \\mathbf{N}^T F \\Bigg|_{x=L} $$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "nonprofit-solution",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 1: Derive the discrete form</b> \n",
+ "\n",
+ "Derive the discrete form of the PDE given above. You can follow the same steps as in the book for the term with $EA$ and the right hand side, but now carrying along the additional term $ku$ from the PDE. Show that this term leads to the $\\int\\mathbf{N}^Tk\\mathbf{N}\\,dx$ term in the $\\mathbf{K}$-matrix. \n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "45074810-ef2e-4976-aed4-732b082ef025",
+ "metadata": {},
+ "source": [
+ "***Your derivation here***"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6240afb2-28a3-49c4-b3d2-fb53ea110b99",
+ "metadata": {},
+ "source": [
+ "## Modification to the FE implementation\n",
+ "\n",
+ "The only change with respect to the procedure as implemented in the book is the formulation of the $\\mathbf{K}$-matrix, which now consists of two terms:\n",
+ "\n",
+ "$$ \\mathbf{K} = \\int \\mathbf{B}^TEA\\mathbf{B} + \\mathbf{N}^Tk\\mathbf{N}\\,dx $$\n",
+ "\n",
+ "To calculate the integral exactly we must use two integration points.\n",
+ "\n",
+ "$$ \\mathbf{K_e} = \\sum_{i=1}^{n_\\mathrm{ip}} \\left(\\mathbf{B}^T(x_i)EA\\mathbf{B}(x_i) + \\mathbf{N}^T(x_i) k\\mathbf{N}(x_i) \\right) w_i$$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eac28a06",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
+ "<p>\n",
+ "<b>Task 2: Code implementation</b> \n",
+ "\n",
+ "The only change needed with respect to the implementation of the book is in the calculation of the element stiffness matrix. Copy the code from the book and add the term related to the distributed support in the right position. \n",
+ " \n",
+ "Use the following parameters: $L=3$ m, $EA=1000$ N, $F=10$ N, $q=0$ N/m (all values are the same as in the book, except for $q$). Additionally, use $k=1000$ N/m$^2$.\n",
+ "\n",
+ "Remarks:\n",
+ "\n",
+ "- The function <code>evaluate_N</code> is already present in the code in the book\n",
+ "- The <code>get_element_matrix</code> function already included a loop over two integration points\n",
+ "- You need to define $k$ somewhere. To allow for varying $k$ as required below, it is convenient to make $k$ a second argument of the <code>simulate</code> function and pass it on to lower level functions from there (cf. how $EA$ is passed on)\n",
+ "\n",
+ "Check the influence of the distributed support on the solution:\n",
+ "\n",
+ "- First use $q=0$ N/m and $k=1000$ N/$mm^2$\n",
+ "- Then set $k$ to zero and compare the results\n",
+ "- Does the influence of the supported spring on the solution make sense?\n",
+ "</p>\n",
+ "\n",
+ "</div>\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "retired-cartoon",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# YOUR_CODE_HERE"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "303429de",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px; width: 95%\">\n",
+ "\n",
+ "<p>\n",
+ "\n",
+ "<b>Task 3: Investigate the influence of discretization on the quality of the solution</b>\n",
+ "\n",
+ "- How many elements do you need to get a good solution?\n",
+ "- How about when the stiffness of the distributed support is increased to $k=10^6$ N/$m^2$\n",
+ "</p>\n",
+ "\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "e35e64ac-5e72-4575-bbb1-371fa524a747",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# YOUR_CODE_HERE"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d9665a79",
+ "metadata": {},
+ "source": [
+ "**End of notebook.**\n",
+ "<h2 style=\"height: 60px\">\n",
+ "</h2>\n",
+ "<h3 style=\"position: absolute; display: flex; flex-grow: 0; flex-shrink: 0; flex-direction: row-reverse; bottom: 60px; right: 50px; margin: 0; border: 0\">\n",
+ " <style>\n",
+ " .markdown {width:100%; position: relative}\n",
+ " article { position: relative }\n",
+ " </style>\n",
+ " <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">\n",
+ " <img alt=\"Creative Commons License\" style=\"border-width:; width:88px; height:auto; padding-top:10px\" src=\"https://i.creativecommons.org/l/by/4.0/88x31.png\" />\n",
+ " </a>\n",
+ " <a rel=\"TU Delft\" href=\"https://www.tudelft.nl/en/ceg\">\n",
+ " <img alt=\"TU Delft\" style=\"border-width:0; width:100px; height:auto; padding-bottom:0px\" src=\"https://gitlab.tudelft.nl/mude/public/-/raw/main/tu-logo/TU_P1_full-color.png\" />\n",
+ " </a>\n",
+ " <a rel=\"MUDE\" href=\"http://mude.citg.tudelft.nl/\">\n",
+ " <img alt=\"MUDE\" style=\"border-width:0; width:100px; height:auto; padding-bottom:0px\" src=\"https://gitlab.tudelft.nl/mude/public/-/raw/main/mude-logo/MUDE_Logo-small.png\" />\n",
+ " </a>\n",
+ " \n",
+ "</h3>\n",
+ "<span style=\"font-size: 75%\">\n",
+ "© Copyright 2024 <a rel=\"MUDE\" href=\"http://mude.citg.tudelft.nl/\">MUDE</a> TU Delft. This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">CC BY 4.0 License</a>."
+ ]
+ }
+ ],
+ "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.4"
+ },
+ "latex_envs": {
+ "LaTeX_envs_menu_present": true,
+ "autoclose": false,
+ "autocomplete": true,
+ "bibliofile": "biblio.bib",
+ "cite_by": "apalike",
+ "current_citInitial": 1,
+ "eqLabelWithNumbers": true,
+ "eqNumInitial": 1,
+ "hotkeys": {
+ "equation": "Ctrl-E",
+ "itemize": "Ctrl-I"
+ },
+ "labels_anchors": false,
+ "latex_user_defs": false,
+ "report_style_numbering": false,
+ "user_envs_cfg": false
+ },
+ "widgets": {
+ "application/vnd.jupyter.widget-state+json": {
+ "state": {},
+ "version_major": 2,
+ "version_minor": 0
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}