{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \n", "
\n", "\n", "# Exploratory Computing with Python\n", "*Developed by Mark Bakker*\n", "## Notebook 12: Object oriented programming" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this Notebook, we learn what Object Oriented Programming (OOP) is, what Classes are and how to write our own, and we learn how to make graphs using OOP and and the `matplotlib` package." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### A Triangle Class\n", "So far, we have learned what is called *functional* programming. In functional programming you write or use functions that manipulate data. For example, consider the case where we have to deal with a number of triangles. For each triangle we want to be able to compute its area, and we want to be able to plot it, and fill the inside with a color. Say we have an arbitrary number of $N$ triangles. For each triangle we need to store the $(x,y)$ values of all three corner points. So we create an array for the $x$ values of the three corner point, we create an array for the three $y$ values of each corner point. Then we write a function that computes the area of a triangle given its three corners, and we write a function that plots the triangle given the three corner points, maybe fill each triangle with a color. And finally, we need to loop through all the triangles. This all sounds like a bit of work, but it is tractable. It gets more complicated when we want to change the corner point of one triangle. We have to know its place in the array, and change the correct corner point.\n", "\n", "It gets even more complicated when we have to deal with both triangles and rectangles. Triangles have three corner points, while rectangles have four corner points. The function to compute the area of a rectangle very different, hence we have to make sure we call the area function for a triangle when we have a triangle, and the area function for a rectangle when we have a rectangle. The plotting is not much different, but we have to supply it four corner points rather than three. This gets a bit messier already. Wouldn't it be nice if it was possible to organize the data and functions in such a way that the data itself knows how to compute its area or how to plot itself? That may sound magical, but that is exactly what Object Oriented Programming does. \n", "\n", "Object oriented programming is, in essence, just another way of organizing your data and functions. Rather than defining and storing them separately, the data and functions are stored and bound together in what is called a *Class*. The data that are stored are called *attributes*, and the functions are called *methods*. \n", "This is probably easiest understood by writing a class and using it. Consider, for example, the class `Triangle` that stores the coordinates of the three corner points. Don't worry about the syntax yet (we will get back to that). Run the code below so we can start using the class. " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "class Triangle:\n", " def __init__(self, x0y0, x1y1, x2y2):\n", " self.x0y0 = x0y0\n", " self.x1y1 = x1y1\n", " self.x2y2 = x2y2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that the `Triangle` class is defined, we can start creating triangles. We can call the `Triangle` class just like a function and we need to provide it tuples of the three corner points. The `Triangle` class returns what is called an object. An object is an instance of a class. Note also, that when you type \n", "\n", "`Triangle(` \n", "\n", "and hit [shift][tab], a small box pops up showing what input arguments are expected (you don't need to provide the `self` argument; more on that later). Let's create a triangle with corners (0,1), (3,0) and (2,3)." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "t1 = Triangle((0, 1), (3, 0), (2, 3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`t1` is now an instance of the class `Triangle`. We simply say that `t1` is a triangle. We have stored the three corner points of the triangle. Hence, each `Triangle` object has three attributes. You can find out what attributes an object has by typing \n", "\n", "`t1.` \n", "\n", "(don't forget the dot) and then hit the [TAB] key. The attributes can be accessed with the *dot syntax*." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "<__main__.Triangle object at 0x11a0618d0>\n", "(0, 1)\n", "(3, 0)\n", "(2, 3)\n" ] } ], "source": [ "print(t1) # not very useful\n", "print(t1.x0y0) # first corner point\n", "print(t1.x1y1) # second corner point\n", "print(t1.x2y2) # third corner point" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's get back to the `Triangle` class. When we call the `Triangle` class (official lingo: we create a `Triangle` object, or more officially yet: we create an instance of the `Triangle` class), Python calls the `__init__` function. This function is called the *constructor*. It constructs an object. In the constructor you define what arguments need to be provided to create a triangle. The name `__init__` (that is *two* underscores before and after the word `init`) is required (it is one of the few unfortunate name choices of the Python language). The first argument is `self` and tells Python what the object itself is called inside the class. \n", "\n", "We saw above that typing `print(t1)` returns a meaningless message. This can be resolved by including a representation function, which needs to be called `__repr__`. This function is called when the object is printed (or converted to a string)." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Triangle with corners: (0, 1), (3, 0), (2, 3)\n" ] } ], "source": [ "class Triangle:\n", " def __init__(self, x0y0, x1y1, x2y2):\n", " self.x0y0 = x0y0\n", " self.x1y1 = x1y1\n", " self.x2y2 = x2y2\n", " def __repr__(self):\n", " return f'Triangle with corners: {self.x0y0}, {self.x1y1}, {self.x2y2}'\n", " \n", "t1 = Triangle((0, 1), (3, 0), (2, 3))\n", "print(t1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the Triangle class, the three corner points are stored as three tuples. Hence, the $x$ value of the first corner point is `self.x0y0[0]` and the $y$ value is `self.x0y0[1]`. It may be useful to store one array of the three $x$ values of the three corner points and one array of the three $y$ values of the corner points. If those are stored, it is fairly easy to compute the area $A$ of a triangle using the following formula\n", "\n", "$A = \\frac{1}{2}|(x_0-x_2)(y_1-y_0) - (x_0-x_1)(y_2-y_0)|$\n", "\n", "Let's modify the `Triangle` class to include these two additional attributes and an `area` function" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "class Triangle:\n", " def __init__(self, x0y0, x1y1, x2y2):\n", " self.x0y0 = x0y0\n", " self.x1y1 = x1y1\n", " self.x2y2 = x2y2\n", " self.x = np.array([self.x0y0[0], self.x1y1[0], self.x2y2[0]])\n", " self.y = np.array([self.x0y0[1], self.x1y1[1], self.x2y2[1]])\n", " def __repr__(self):\n", " return f'Triangle with corners: {self.x0y0}, {self.x1y1}, {self.x2y2}'\n", " def area(self):\n", " A = 0.5 * np.abs((self.x[0] - self.x[2]) * (self.y[1] - self.y[0]) - \n", " (self.x[0] - self.x[1]) * (self.y[2] - self.y[0]))\n", " return A" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the `area` function gets passed the object `self`. Once it knows what `self` is, it has access to all its attributes and functions. We can now create a `Triangle` object and compute its area as follows (don't forget to run the new `Triangle` class above first)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4.0\n" ] } ], "source": [ "t1 = Triangle( (0,1), (3,0), (2,3) )\n", "print(t1.area())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the code above, the `area` function is called using the *dot* syntax, where `self` in the function is automatically replaced with the variable before the dot (in this case `t1`). The *dot* syntax is short for the much longer" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4.0\n" ] } ], "source": [ "print(Triangle.area(t1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that classes are very convenient, as the triangle object knows what its own corner points are. When typing `t1.`[TAB], not only all attributes but also all functions of an object are shown. Another way is to use the `dir` function. " ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['__class__',\n", " '__delattr__',\n", " '__dict__',\n", " '__dir__',\n", " '__doc__',\n", " '__eq__',\n", " '__format__',\n", " '__ge__',\n", " '__getattribute__',\n", " '__gt__',\n", " '__hash__',\n", " '__init__',\n", " '__init_subclass__',\n", " '__le__',\n", " '__lt__',\n", " '__module__',\n", " '__ne__',\n", " '__new__',\n", " '__reduce__',\n", " '__reduce_ex__',\n", " '__repr__',\n", " '__setattr__',\n", " '__sizeof__',\n", " '__str__',\n", " '__subclasshook__',\n", " '__weakref__',\n", " 'area',\n", " 'x',\n", " 'x0y0',\n", " 'x1y1',\n", " 'x2y2',\n", " 'y']" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dir(t1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's expand the `Triangle` class by adding a function that plots a filled triangle. The color of the triangle is supplied with a keyword argument in the constructor. Hence, when it is not provided, the default value will be used." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "class Triangle:\n", " def __init__(self, x0y0, x1y1, x2y2, color='b'):\n", " self.x0y0 = x0y0\n", " self.x1y1 = x1y1\n", " self.x2y2 = x2y2\n", " self.x = np.array([self.x0y0[0], self.x1y1[0], self.x2y2[0]])\n", " self.y = np.array([self.x0y0[1], self.x1y1[1], self.x2y2[1]])\n", " self.color = color\n", " def __repr__(self):\n", " return f'Triangle with corners: {self.x0y0}, {self.x1y1}, {self.x2y2}'\n", " def area(self):\n", " A = 0.5 * np.abs((self.x[0]-self.x[2])*(self.y[1]-self.y[0]) - \n", " (self.x[0]-self.x[1])*(self.y[2]-self.y[0]))\n", " return A\n", " def plot(self):\n", " plt.fill(self.x, self.y, color=self.color)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's create three triangles and store them in a list. Then we loop through the triangles in the list and plot them in one graph. Note how we can loop through the triangles in the list `tlist` as follows:\n", "\n", "`for t in tlist:`\n", "\n", "So every time we go through the loop, `t` is the next triangle in the list `tlist`." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "tlist = [] # start with an empty list\n", "t1 = Triangle((0, 1), (5, 0), (3, 3), 'b')\n", "tlist.append(t1) # add t1 to the list\n", "t2 = Triangle((3, 4), (1, 6), (-2, 3), 'r')\n", "tlist.append(t2)\n", "t3 = Triangle((8, -1), (6, 4), (2, 6), 'g')\n", "tlist.append(t3)\n", "plt.figure()\n", "for t in tlist:\n", " t.plot()\n", "plt.axis('scaled');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similarly, the total area of the three triangles is" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "total area: 20.5\n" ] } ], "source": [ "areatot = 0.0\n", "for t in tlist:\n", " areatot += t.area()\n", "print(f'total area: {areatot}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 1. A Circle class\n", "Create a `Circle` class that stores the $(x,y)$ coordinates of the center of a circle and the radius $R$ of the circle. Class functions are: `area`, which returns the area of the circle and `plot`, which plots a filled circle using a transparancy of 0.5 (i.e., use keyword argument `alpha=0.5` in the `fill` function). The input argument of the `plot` function is a radius $R^*$. When the radius of the circle is less than $R^*$, fill the circle with the color blue. When the radius of the circle is larger than or equal to $R^*$, fill the circle with the color red. Demonstrate that your `Circle` class works by loading the text file `circle_data.txt`. This file contains the $x$, $y$, and $R$ data for 20 circles. Compute and report the total area of all the circles in the file. Make a plot of the 20 circles to demonstrate that the colors are assigned correctly, using $R^*=1$." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answers to Exercise 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 2. Flow to a set of extraction and injection wells\n", "Consider an extraction well with a discharge $Q$. The well is located at $(x,y)=(x_w,y_w)$ in an aquifer with thickness $H$ and hydraulic conductivity $k$. The head at a radial distance $R$ from the well is fixed to $h_0$. The groundwater head $h$ decreases towards the well as (e.g., Eq. 11.4 in Verruijt (2012) Soil Mechanics)\n", "\n", "$$h = \\frac{Q}{2\\pi kH} \\ln\\left(\\frac{r}{R}\\right) + h_0$$\n", "\n", "where $r$ is the radial distance from the well $r=\\sqrt{(x-x_w)^2+(y-y_w)^2}$. \n", "\n", "Next, consider a system with $N$ extraction and injection wells near the center of a large area; the sum of the discharges of all extraction and injection wells is zero (i.e., all water that is extracted is also injected; this is often the case for pump-and-treat systems, cooling systems, building pit dewatering, etc.). The change in head caused by all wells together is approximately zero along a circle with radius $R$. The head distribution for a system of $N$ wells may be written as (e.g., Eq. 11.9 in Verruijt, 2010, Soil Mechanics)\n", "\n", "$$h = \\sum_{n=1}^N \\frac{Q_n}{2\\pi kH} \\ln\\left(\\frac{r_n}{R}\\right)$$\n", "\n", "where $Q_n$ is the discharge of well $n$ (positive for extraction) located at $(x_n,y_n)$, and $r_n=\\sqrt{(x-x_n)^2+(y-y_n)^2}$ is the distance from well $n$.\n", "\n", "Write a class `Well` that stores the location of a well, the discharge of a well, the radius $R$ of the circular area, and the aquifer parameters $k$ and $H$. The well class has one method called `head`, which takes $x,y$ coordinates as input arguments and returns the contribution of the well to the head at $x,y$ (the term $Q_n/(2\\pi kH)\\ln(r_n/R)$ in the summation above). \n", "\n", "Test your implementation for an aquifer with $k=2$ m/d, $H=10$ m, $R=1000$ m, and a system of three wells: one extraction well (with postive discharge) and two injection wells (with negative discharge). \n", "\n", "* $(x_w,y_w)=(0,0)$, $Q=100$ m$^3$/d\n", "* $(x_w,y_w)=(-20,0)$, $Q=-50$ m$^3$/d\n", "* $(x_w,y_w)=(20,0)$, $Q=-50$ m$^3$/d\n", "\n", "When your implementation is correct, the head caused by the three wells at $(x,y)=(20,5)$ is 0.2968 m. Plot the variation of the head along the line $y=1$ for $x$ varying from -40 to +40." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answers to Exercise 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Arrays are objects\n", "Now that you have learned about OOP, you may realize that many of the Python features you use are actually based on OOP. For example, when you create an array, the array is an object. " ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "type of x: \n" ] } ], "source": [ "x = np.arange(12)\n", "print('type of x:', type(x))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Hence, an array has attributes and class methods associated with it. You can type `dir(x)` to find out all attributes and methods (there are many). Some of the attributes of an array include the number of dimensions and the shape. You can even change the shape (as long as you make sure the shape fits the array) by modifying the shape attribute." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "number of dimensions of x: 1\n", "shape of x: (12,)\n", "new shape of x: (4, 3)\n", "[[ 0 1 2]\n", " [ 3 4 5]\n", " [ 6 7 8]\n", " [ 9 10 11]]\n" ] } ], "source": [ "print(f'number of dimensions of x: {x.ndim}')\n", "print(f'shape of x: {x.shape}')\n", "x.shape = (4, 3)\n", "print(f'new shape of x: {x.shape}')\n", "print(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An array also has a number of functions, including a function that returns the mean value of the array or the maximum value of an array." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mean of x: 5.5\n", "max of x: 11\n" ] } ], "source": [ "print(f'mean of x: {x.mean()}')\n", "print(f'max of x: {x.max()}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plotting features are objects\n", "All plotting commands we have used so far are functions that are part of the `matplotlib` package. Not surpringly, `matplotlib` has an object-oriented design. Plots may be created by making use of the object-oriented structure. This requires a bit of additional typing, but in the end, we gain a lot of additional flexibility.\n", "\n", "Using the OO syntax, we first create a `figure` object and specify the size using the `figsize` keyword argument (the size of the figure is specified in inches), then we add an axis to the figure with the `add_axes` command (note that it is `axes` with an `e`) by specifying the *relative* location of the axis in the figure. The location of the left, bottom, width, and height are specified in relative coordinates (both the horizontal and vertical directions run from 0 to 1). To plot, we use the `plot` method of the axis." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x = np.linspace(0, 2, 100)\n", "y = x ** 2\n", "fig = plt.figure(figsize=(10, 5))\n", "ax1 = fig.add_axes([0.1, 0.1, 0.8, 0.8])\n", "ax1.plot(x, y, 'b')\n", "ax1.set_xlabel('x')\n", "ax1.set_ylabel('y')\n", "ax1.set_title('Example figure');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can add as many axes to the figure as we want and decide exactly where each axis is located. " ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x = np.linspace(0, 2, 100)\n", "y = x ** 2\n", "fig = plt.figure(figsize=(10, 5))\n", "ax1 = fig.add_axes([0.1, 0.1, 0.8, 0.8])\n", "ax1.plot(x, y, 'b')\n", "ax1.set_xlabel('x')\n", "ax1.set_ylabel('y')\n", "ax1.set_title('Example figure')\n", "ax2 = fig.add_axes([0.18, 0.5, 0.4, 0.3])\n", "ax2.plot(x,-y,'r')\n", "ax2.set_xlabel('x-axis')\n", "ax2.set_ylabel('vertical value')\n", "ax2.set_title('Second axis');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Another way to add an axis to a figure is using the `add_subplot` function, which works similar to the `np.subplot` functin. If you want just one axis of default size, you simply specify `111` (1 row, 1 column, figure 1)." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig = plt.figure()\n", "ax1 = fig.add_subplot(111)\n", "ax1.plot(x, y, 'b');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you want fancier options to create a grid of graphs, use the `subplot2grid` function, which allows you define a grid of graphs (3 by 3 in the example below). Then you can add graphs by specifying the row and column with the second argument (these are 0 based, so the upper left-hand corner is `loc=(0, 0)`). And you can, optionally, specify that a graph spans multiple graphs in the row or column direction. " ] }, { "cell_type": "code", "execution_count": 19, "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=(8, 6))\n", "ax1 = plt.subplot2grid((3, 3), (0, 0), colspan=3)\n", "ax2 = plt.subplot2grid((3, 3), (1, 0), rowspan=2)\n", "ax3 = plt.subplot2grid((3, 3), (1, 1), rowspan=2, colspan=2)\n", "ax1.plot(x, y)\n", "ax2.plot(x, -y)\n", "ax3.plot(x, y ** 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Matplotlib patches\n", "The plotting package `matplotlib` includes a set of classes to define shapes, which are called *patches* in `matplotlib`. There are patches for many different shapes including circles, ellipses, polygons, wedges, and arrows. Here we learn how to draw these patches. \n", "\n", "The process for adding a patch to a graph is always the same. First you create an axis, then you create a patch object and you add the patch object to the axis. Each patch object has a few input arguments and a number of keyword arguments. The keyword arguments include: `ec` for edge color, `fc` for face color, `alpha` for transparancy, and `zorder` for the order in which they are plotted (the patch with the highest `zorder` value lies on top). The names of all patch classes start with a capital: `Circle`, `Ellipse`, `Polygon`, `Wedge`, `Arrow` (in fact, it is customary in Python to have all classes start with a capital). You need to import these classes from `matplotlib.patches` to be able to use them. Use the help system to learn about the required input arguments. The graph below contains two circles, where the smaller one is on top of the larger one. The face color of the graph is set to the same color as the small circle, so that it looks like the large circle has a hole. The aspect ratio of the axis is set to `'equal'` when the axis is created. The `autoscale` function needs to be called to set the limits of the axis such that the patches fit exactly in the axis. Alternatively, you can call the `ax.set_xlim` and `ax.set_ylim` functions to select limits of your own choice." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from matplotlib.patches import Circle\n", "fig = plt.figure()\n", "ax = fig.add_subplot(111, facecolor='violet', aspect='equal')\n", "small = Circle(xy=(3, 5), radius=1, fc='violet', ec='violet', zorder=2)\n", "big = Circle(xy=(2, 4), radius=3, fc='dodgerblue', ec='dodgerblue', zorder=1)\n", "ax.add_patch(small)\n", "ax.add_patch(big)\n", "ax.autoscale()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 3. Matplotlib patches\n", "Write Python code to create the figure shown below using `matplotlib` patches. Use colors of your own choice. Write 'circle', 'ellipse', etc. inside the corresponding patches using the `ax.text` function.\n", "\n", "\"Patches\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answers to Exercise 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 4. 3D - Spiral\n", "\n", "Consider the $x$, $y$, $z$ coordinates of a three-dimensional spiral\n", "\n", "$$x(t) = a\\cos(t)$$\n", "$$y(t) = a\\sin(t)$$ \n", "$$z(t) = bt$$\n", "\n", "where $a$ and $b$ are constants and $t$ is a parameter that varies. Write a function that takes $a$, $b$, and an array $t$ as input arguments and returns arrays $x$, $y$, and $z$. \n", "\n", "Next, import the 3D plotting capabilities of `matplotlib` with the command \n", "`from mpl_toolkits.mplot3d import Axes3D`. \n", "Plot a three-dimensional curve by specifying the keyword `projection='3d'` when creating the axis. You can than plot on that axis using `ax.plot` by simply specifying $x$, $y$, *and* $z$. Plot two spirals on the same graph. Use $a=4$ an $b=1$ for the first spiral, and $a=2$, $b=2$ for the second spiral; vary $t$ form 0 to 20 with 100 points. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answers to Exercise 4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Answers to the exercises" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answers to Exercise 1" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "total area: 67.89637035591662\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "class Circle:\n", " def __init__(self, x0, y0, R):\n", " self.x0 = x0\n", " self.y0 = y0\n", " self.R = R\n", " def area(self):\n", " A = np.pi * self.R ** 2\n", " return A\n", " def plot(self, Rstar):\n", " if self.R < Rstar:\n", " color = 'b'\n", " else:\n", " color = 'r'\n", " alpha = np.linspace(0, 2 * np.pi, 100)\n", " plt.fill(self.x0 + self.R * np.cos(alpha), self.y0 + self.R * np.sin(alpha), \n", " color=color, alpha=0.5)\n", "\n", "data = np.loadtxt('circle_data.txt')\n", "clist = []\n", "for i in range(20):\n", " c = Circle(data[i, 0], data[i, 1], data[i, 2])\n", " clist.append(c)\n", "areatot = 0.0\n", "plt.figure()\n", "for c in clist:\n", " areatot += c.area()\n", " c.plot(1.0)\n", "plt.axis('scaled')\n", "print(f'total area: {areatot}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Back to Exercise 1\n", "\n", "Answers to Exercise 2" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "head at (20, 5) is: 0.2968318108714483\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "class Well:\n", " def __init__(self, xw, yw, Q, k, H, R):\n", " self.xw = xw\n", " self.yw = yw\n", " self.Q = Q\n", " self.k = k\n", " self.H = H\n", " self.R = R\n", " def head(self, x, y):\n", " r = np.sqrt((x - self.xw) ** 2 + (y - self.yw) ** 2)\n", " h = self.Q / (2 * np.pi * self.k * self.H) * np.log(r / self.R)\n", " return h\n", " \n", "w1 = Well(0, 0, 100, 2, 10, 1000)\n", "w2 = Well(-20, 0, -50, 2, 10, 1000)\n", "w3 = Well(20, 0, -50, 2, 10, 1000)\n", "wells = [w1, w2, w3]\n", "\n", "h = 0.0\n", "for w in wells:\n", " h += w.head(20, 5)\n", "print(f'head at (20, 5) is: {h}')\n", "\n", "x = np.linspace(-40, 40, 101)\n", "h = np.zeros_like(x)\n", "for w in wells:\n", " h += w.head(x, 1)\n", "plt.figure()\n", "plt.plot(x, h)\n", "plt.xlabel('x')\n", "plt.ylabel('head along y=1');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Back to Exercise 2\n", "\n", "Answers to Exercise 3" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from matplotlib.patches import Circle, Ellipse, Polygon, Arrow, Wedge\n", "fig = plt.figure(figsize=(10, 5))\n", "ax = fig.add_axes([.1, .1, .8, .8], aspect='equal')\n", "c1 = Circle(xy=(0, 0), radius=2, fc='dodgerblue')\n", "ax.add_patch(c1)\n", "a1 = Arrow(x=2, y=0, dx=2, dy=0, fc='r')\n", "ax.add_patch(a1)\n", "e1 = Ellipse(xy=(8, 0), width=8, height=4, fc='b')\n", "ax.add_patch(e1)\n", "a2 = Arrow(x=0, y=2, dx=0, dy=2, fc='r')\n", "ax.add_patch(a2)\n", "w1 = Wedge(center=(0, 6), r=2, theta1=45, theta2=0, fc='b')\n", "ax.add_patch(w1)\n", "a3 = Arrow(x=-2, y=0, dx=-2, dy=0, fc='r')\n", "ax.add_patch(a3)\n", "p1 = Polygon(xy=[(-4, 0), (-6, 2), (-8, 1.5), (-10, 0),\n", " (-10, -1.5), (-7, -2)], fc='b')\n", "ax.add_patch(p1)\n", "ax.set_xlim(-10, 12)\n", "ax.set_xticks(np.arange(-10, 13))\n", "ax.set_ylim(-2, 8)\n", "ax.set_yticks(np.arange(-2, 9, 1))\n", "ax.text(0, 0, 'circle', ha='center')\n", "ax.text(8, 0, 'ellipse', ha='center')\n", "ax.text(-7, 0, 'polygon', ha='center')\n", "ax.text(0, 5, 'wedge', ha='center');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Back to Exercise 3\n", "\n", "Answers to Exercise 4" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from mpl_toolkits.mplot3d import Axes3D\n", "\n", "def spiral(a, b, t):\n", " x = a * np.cos(t)\n", " y = a * np.sin(t)\n", " z = b * t\n", " return x, y, z\n", "\n", "t = np.linspace(0, 20, 100)\n", "x1, y1, z1 = spiral(4, 1, t)\n", "x2, y2, z2 = spiral(2, 2, t)\n", "\n", "fig = plt.figure()\n", "ax = fig.add_subplot(111, projection='3d')\n", "ax.plot(x1, y1, z1)\n", "ax.plot(x2, y2, z2);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Back to Exercise 4" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.0" } }, "nbformat": 4, "nbformat_minor": 1 }