diff --git a/2-finite-difference-method/.gitignore b/2-finite-difference-method/.gitignore new file mode 100644 index 0000000..b631b4c --- /dev/null +++ b/2-finite-difference-method/.gitignore @@ -0,0 +1,4 @@ +.ipynb_checkpoints +*.pyc +.env +__pycache__ diff --git a/2-finite-difference-method/LICENSE b/2-finite-difference-method/LICENSE new file mode 100644 index 0000000..debc4de --- /dev/null +++ b/2-finite-difference-method/LICENSE @@ -0,0 +1,55 @@ +Instructional Material + +All instructional material is made available under the Creative +Commons Attribution license. You are free: + +* to Share---to copy, distribute and transmit the work +* to Remix---to adapt the work + +Under the following conditions: + +* Attribution---You must attribute the work using "Copyright (c) + Barbagroup" (but not in any way that suggests that we + endorse you or your use of the work). Where practical, you must + also include a hyperlink to https://github.com/numerical-mooc/numerical-mooc. + +With the understanding that: + +* Waiver---Any of the above conditions can be waived if you get + permission from the copyright holder. +* Other Rights---In no way are any of the following rights + affected by the license: + * Your fair dealing or fair use rights; + * The author's moral rights; + * Rights other persons may have either in the work itself or in + how the work is used, such as publicity or privacy rights. * +* Notice---For any reuse or distribution, you must make clear to + others the license terms of this work. The best way to do this is + with a link to http://creativecommons.org/licenses/by/3.0/. + +For the full legal text of this license, please see: + http://creativecommons.org/licenses/by/3.0/legalcode + +Software + +The MIT License (MIT) + +Copyright (c) 2014 Barba group + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/2-finite-difference-method/README.md b/2-finite-difference-method/README.md new file mode 100644 index 0000000..fa40829 --- /dev/null +++ b/2-finite-difference-method/README.md @@ -0,0 +1,55 @@ +# Practical Numerical Methods with Python + +This project started in 2014 as a multi-campus, connected course (plus MOOC) on numerical methods for science and engineering. + +In Fall 2015 and 2016, second and third run of the connected courses, we had these instructors participating (using the materials as part of their syllabus): +- [Lorena A. Barba](http://lorenabarba.com), George Washington University, USA +- [Ian Hawke](http://www.southampton.ac.uk/maths/about/staff/ih3.page), Southampton University, UK +- [Bernard Knaepen](http://depphys.ulb.ac.be/bknaepen/), Université Libre de Bruxelles, Belgium + + +[**"Practical Numerical Methods with Python"**](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about) is an open, online course hosted on an independent installation of the [Open edX](http://code.edx.org) software platform for MOOCs. +The MOOC (massive open online course) was run in 2014 for the first time by Prof. Barba at the George Washington University. At the same time, two other participating instructors ran a local course, for credit at their institution. + +### The MOOC + +You can register for the MOOC at any time in the [GW Online Open edX](http://openedx.seas.gwu.edu/) platform to experience the complete course (including quizzes, examples and discussion board). + +All content is open —really open, i.e., you can use, share, mod, remix— and most is available outside the course platform also (on GitHub and YouTube). + +#### Find the list of IPython Notebooks, with links to nbviewer, in the [Wiki](https://github.com/numerical-mooc/numerical-mooc/wiki). + +## Getting Started + +1. Introduction to the command line: [OS X version](https://github.com/numerical-mooc/numerical-mooc/blob/master/lessons/00_getting_started/00_01_Intro_to_the_command_line_osx.md); [RedHat version](https://github.com/numerical-mooc/numerical-mooc/blob/master/lessons/00_getting_started/00_01_Intro_to_the_command_line_redhat.md) +2. [Installing Jupyter](https://github.com/numerical-mooc/numerical-mooc/blob/master/lessons/00_getting_started/00_02_Installing_Jupyter.md) +3. [Introduction to Jupyter notebooks](https://github.com/numerical-mooc/numerical-mooc/blob/master/lessons/00_getting_started/00_03_Intro_to_Jupyter_notebook.md) +4. [Introduction to git](https://github.com/numerical-mooc/numerical-mooc/blob/master/lessons/00_getting_started/00_04_Intro_to_git.md) + +## Course Modules + +1. [**The phugoid model of glider flight.**](https://github.com/numerical-mooc/numerical-mooc/tree/master/lessons/01_phugoid) +Described by a set of two nonlinear ordinary differential equations, the phugoid model motivates numerical time integration methods, and we build it up starting from one simple equation, so that the unit can include 3 or 4 lessons on initial value problems. This includes: a) Euler's method, 2nd-order RK, and leapfrog; b) consistency, convergence testing; c) stability +Computational techniques: array operations with NumPy; symbolic computing with SymPy; ODE integrators and libraries; writing and using functions. +2. [**Space and Time—Introduction to finite-difference solutions of PDEs.**](https://github.com/numerical-mooc/numerical-mooc/tree/master/lessons/02_spacetime) +Starting with the simplest model represented by a partial differential equation (PDE)—the linear convection equation in one dimension—, this module builds the foundation of using finite differencing in PDEs. (The module is based on the “CFD Python” collection, steps 1 through 4.) It also motivates CFL condition, numerical diffusion, accuracy of finite-difference approximations via Taylor series, consistency and stability, and the physical idea of conservation laws. +Computational techniques: more array operations with NumPy and symbolic computing with SymPy; getting better performance with NumPy array operations. +3. [**Riding the wave: convection problems.**](https://github.com/numerical-mooc/numerical-mooc/tree/master/lessons/03_wave) +Starting with an overview of the concept of conservation laws, this module uses the traffic-flow model to study different solutions methods for problems with shocks: upwind, Lax-Friedrichs, Lax-Wendroff, MacCormack, then MUSCL (discussing limiters). Reinforces concepts of numerical diffusion and stability, in the context of solutions with shocks. It will motivate spectral analysis of schemes, dispersion errors, Gibbs phenomenon, conservative schemes. +4. [**Spreading out: diffusion problems.**](https://github.com/numerical-mooc/numerical-mooc/tree/master/lessons/04_spreadout) +This module deals with solutions to parabolic PDEs, exemplified by the diffusion (heat) equation. Starting with the 1D heat equation, we learn the details of implementing boundary conditions and are introduced to implicit schemes for the first time. Another first in this module is the solution of a two-dimensional problem. The 2D heat equation is solved with both explicit and implict schemes, each time taking special care with boundary conditions. The final lesson builds solutions with a Crank-Nicolson scheme. +5. [**Relax and hold steady: elliptic problems.**](https://github.com/numerical-mooc/numerical-mooc/tree/master/lessons/05_relax) +Laplace and Poisson equations (steps 9 and 10 of “CFD Python”), seen as systems relaxing under the influence of the boundary conditions and the Laplace operator. Iterative methods for algebraic equations resulting from discretizign PDEx: Jacobi method, Gauss-Seidel and successive over-relaxation methods. Conjugate gradient methods. + + +Planned modules: +- **Perform like a pro: making your codes run faster** +Getting performance out of your numerical Python codes with just-in-time compilation, targeting GPUs with Numba and PyCUDA. +- **Boundaries take over: the boundary element method (BEM).** +Weak and boundary integral formulation of elliptic partial differential equations; the free space Green's function. Boundary discretization: basis functions; collocation and Galerkin systems. The BEM stiffness matrix: dense versus sparse; matrix conditioning. Solving the BEM system: singular and near-singular integrals; Gauss quadrature integration. + +## Sponsors + +The initial deployment of the GW SEAS Open edX instance and the creation of the first course in the platform (Fall 2014) were funded with a seed grant from the GW VP for Online Education and Academic Innovation, TA support from the GW School of Engineering and Applied Sciences, and additional support from Nvidia Corp. Academic Programs and Amazon AWS (donated cloud credits for the first year). + + diff --git a/2-finite-difference-method/files/CourseNotesMATH3018_6141.pdf b/2-finite-difference-method/files/CourseNotesMATH3018_6141.pdf new file mode 100644 index 0000000..28fa05d Binary files /dev/null and b/2-finite-difference-method/files/CourseNotesMATH3018_6141.pdf differ diff --git a/2-finite-difference-method/lessons/00_getting_started/00_01_Intro_to_the_command_line_osx.md b/2-finite-difference-method/lessons/00_getting_started/00_01_Intro_to_the_command_line_osx.md new file mode 100644 index 0000000..ff2ac71 --- /dev/null +++ b/2-finite-difference-method/lessons/00_getting_started/00_01_Intro_to_the_command_line_osx.md @@ -0,0 +1,133 @@ +# Intro to the command line + +Welcome! The command line can be one of the most powerful ways to interact with +a variety of computer systems, but it can also be a little confusing at first +glance. This mini-crash-course should help familiarize you with the basics of +command line usage and navigation. + +## Open a terminal! + +Hit `⌘ + Space` to bring up spotlight, then type the first few letters of +`Terminal` and select `Terminal`. + + +## Who am I? + +Time to get started! You likely know your username since you've just logged in, +but sometimes you may have multiple accounts with slight variations on a +username. + +You can always ask the terminal who you are by entering + +```console +whoami +``` + +and hitting \. (From now on, after typing in a command, just hit +\ unless we tell you otherwise.) + +![whoami](./images/1.whoami.gif) + +**Note**: These gifs were made on a Red Hat linux machine, so they'll look a +little bit different than what you see. Don't worry about it. + +## Where am I? + +We know who we are, time to find out *where* we are. You can always find out +what folder you're in by using the "print working directory" command, or `pwd`. +Try it out! + +```console +pwd +``` + +![pwd](./images/2.pwd.gif) + +We're in our home directory. This is the base directory for a regular user in +Linux or OSX. In the SEAS Mac Labs, the home directory is always +`/Users/`. If you're using your own Linux machine, the home directory +is probably `/home/`. + +## What's in here? + +We know who we are and where we are, now it's time to figure out what's in here. +We use the "list" command, `ls`, to view any files or directories that are in +the current folder. + +```console +ls +``` + +![ls](./images/3.ls.gif) + +The items you see above in the gif are all folders. They're the usual folders +created by default in Red Hat Linux. Your home folder is actually the same +folder as your Titan network drive on Windows, so you may have other files and +folders in your home directory. + +## How do I go there? + +To navigate to a new folder, we use the change directory command, `cd`, followed +by the name of the folder. While you *can* type out the full folder name, it's +usually nicer to use what's called Tab-completion. + +Let's change to the `Pictures` directory. Type `cd Pi` and then hit the TAB key +to complete the directory name. Then hit \ + +Now you're in the `Pictures` directory. It's probably empty, but you can check +with `ls`. + +To go back to your home directory, type `cd ..` + +The `..` is a command-line shortcut to move "up" one folder in a directory tree. +Try `cd`-ing into a few other folders and then returning back to your home +directory to get the hang of moving around. + +![cd](./images/4.cd.gif) + +### Multiple tab-completions + +If there are multiple possible completions for a partial directory name, you can +ask the terminal to display them by hitting TAB twice. Try entering + +```console +cd Do +``` + +and then hit TAB twice to see the list of matching directories. Then you can add +a `c` and Tab-complete `Documents`. + +![cdtabtab](./images/5.cdtabtab.gif) + +## Quick config step + +Now that we have a handle on basic terminal navigation, we are going to make a +few tweaks to this setup to make it friendlier. Copy the two lines below by +selecting them and hitting `⌘+c` and then paste them into the terminal using +`⌘+v` and hit \. + +```console +echo "export PATH=/Applications/anaconda/bin:\$PATH" >> .bash_profile +``` + +(If you are following along and aren't at GW, don't do this, it only applies to +the GW Mac Labs) + +Now, to activate the options we just selected, type the following line in the +terminal and hit \ + +```console +source .bash_profile +``` + +It should look a little something like this: + +![image](./images/6.bashrc.gif) + +## Make sure Anaconda is on your PATH + +```console +python --version +``` + +That command should return a version number >= `3.5` and it should also say Anaconda. diff --git a/2-finite-difference-method/lessons/00_getting_started/00_01_Intro_to_the_command_line_redhat.md b/2-finite-difference-method/lessons/00_getting_started/00_01_Intro_to_the_command_line_redhat.md new file mode 100644 index 0000000..5e363af --- /dev/null +++ b/2-finite-difference-method/lessons/00_getting_started/00_01_Intro_to_the_command_line_redhat.md @@ -0,0 +1,138 @@ +# Intro to the command line + +Welcome! The command line can be one of the most powerful ways to interact with +a variety of computer systems, but it can also be a little confusing at first +glance. This mini-crash-course should help familiarize you with the basics of +command line usage and navigation. + + +## Who am I? + +Time to get started! You likely know your username since you've just logged in, +but sometimes you may have multiple accounts with slight variations on a +username. + +First, please open up a terminal using the menu in the upper-left corner (on Red +Hat) and selecting + +> Applications -> System Tools -> Terminal + +You can always ask the terminal who you are by entering + +```Bash +whoami +``` + +and hitting \. (From now on, after typing in a command, just hit +\ unless we tell you otherwise.) + +![whoami](./images/1.whoami.gif) + +## Where am I? + +We know who we are, time to find out *where* we are. You can always find out +what folder you're in by using the "print working directory" command, or `pwd`. +Try it out! + +```Bash +pwd +``` + +![pwd](./images/2.pwd.gif) + +We're in our home directory. This is the base directory for a regular user in +Linux. In the SEAS labs, the home directory is always `/home/seas/`. +If you're using your own Linux machine, the home directory is probably +`/home/`. If you're on a Mac, the home directory is +`/Users/` (they like to be different). + +## What's in here? + +We know who we are and where we are, now it's time to figure out what's in here. +We use the "list" command, `ls`, to view any files or directories that are in +the current folder. + +```Bash +ls +``` + +![ls](./images/3.ls.gif) + +The items you see above in the gif are all folders. They're the usual folders +created by default in Red Hat Linux. Your home folder is actually the same +folder as your Titan network drive on Windows, so you may have other files and +folders in your home directory. + +## How do I go there? + +To navigate to a new folder, we use the change directory command, `cd`, followed +by the name of the folder. While you *can* type out the full folder name, it's +usually nicer to use what's called Tab-completion. + +Let's change to the `Pictures` directory. Type `cd Pi` and then hit the TAB key +to complete the directory name. Then hit \ + +Now you're in the `Pictures` directory. It's probably empty, but you can check +with `ls`. + +To go back to your home directory, type `cd ..` + +The `..` is a command-line shortcut to move "up" one folder in a directory tree. +Try `cd`-ing into a few other folders and then returning back to your home +directory to get the hang of moving around. + +![cd](./images/4.cd.gif) + +### Multiple tab-completions + +If there are multiple possible completions for a partial directory name, you can +ask the terminal to display them by hitting TAB twice. Try entering + +```Bash +cd Do +``` + +and then hit TAB twice to see the list of matching directories. Then you can add +a `c` and Tab-complete `Documents`. + +![cdtabtab](./images/5.cdtabtab.gif) + +## Quick config step + +Now that we have a handle on basic terminal navigation, we are going to make a +few tweaks to this setup to make it friendlier. Copy the two lines below by +selecting them and hitting Ctrl+c and then paste them into the terminal using +Ctrl+Shift+v and hit \. **Note** that Ctrl+v doesn't work, you need to +add Shift. + +```Bash +echo "export PATH=/opt/anaconda/bin:\$PATH" >> .bashrc +echo "export PS1=\"\u \w \"" >> .bashrc +``` + +(If you are following along and aren't at GW, don't copy the first line, that +only applies to the GW Linux labs) + +Now, to activate the options we just selected, type the following line in the +terminal and hit \ + +```Bash +source .bashrc +``` + +It should look a little something like this: + +![image](./images/6.bashrc.gif) + +## Fire up a jupyter notebook! + +It's time to get started! If you're at GW then everything is already installed, +just run + +```Bash +jupyter notebook +``` + +in a terminal and it will launch a notebook server in your browser. If you +*aren't* at GW, then see the next module in Getting Started on installing Python +and Jupyter. diff --git a/2-finite-difference-method/lessons/00_getting_started/00_02_Installing_Jupyter.md b/2-finite-difference-method/lessons/00_getting_started/00_02_Installing_Jupyter.md new file mode 100644 index 0000000..a3d7154 --- /dev/null +++ b/2-finite-difference-method/lessons/00_getting_started/00_02_Installing_Jupyter.md @@ -0,0 +1,41 @@ +# Jupyter Install + +This guide is to help you get Jupyter notebooks up and running on your personal computer. + +## 1. Install Anaconda + +There are several ways to install Python and Jupyter and all of the required libraries to complete this course. You are welcome to try out any of them, but we **strongly** suggest using the Anaconda Python Distribution. It is up-to-date (unlike the versions of Python that may already exist on your Linux or OSX machine) and it also comes with `conda`. We'll get to `conda` a little later, but believe us, it's awesome and you want to have it. + +### Download the installer + +First download the Anaconda installer. Visit http://continuum.io/downloads to download the appropriate installer for your operating system. + +**You must first click the link that says "I Want Python 3.4*"** to select the correct installer. + +![anaconda](./images/anaconda.download.gif) + + +### Run the installer + +Follow the appropriate instructions for your operating system listed on the [Anaconda Install Page](http://docs.continuum.io/anaconda/install). For Linux users, make sure to answer "yes" when the installer asks about editing your `PATH`. + +![addtopath](./images/addtopath.gif) + +Also note that on both Linux and OSX, you have to close the current terminal window and re-open it before the Anaconda installation will be available. + +## 2. Install Jupyter and other libraries + +Once Anaconda is installed, you can then use the included `conda` package to install all of the necessary packages for the course. Open a terminal and run + +```Bash +conda install jupyter numpy scipy sympy matplotlib +``` + +## 3. Test your installation +Once `conda` is finished you should be ready to go! Open a terminal and run + +```Bash +jupyter notebook +``` + +to launch a notebook server. diff --git a/2-finite-difference-method/lessons/00_getting_started/00_03_Intro_to_Jupyter_notebook.md b/2-finite-difference-method/lessons/00_getting_started/00_03_Intro_to_Jupyter_notebook.md new file mode 100644 index 0000000..7a4a642 --- /dev/null +++ b/2-finite-difference-method/lessons/00_getting_started/00_03_Intro_to_Jupyter_notebook.md @@ -0,0 +1,107 @@ +# Intro to Jupyter notebooks + +## What is the Jupyter Notebook? +We'll work extensively with [Jupyter Notebooks](https://jupyter-notebook.readthedocs.org/en/latest/notebook.html) (formerly IPython Notebooks) in this course. They are media-rich documents that combine text with markown formatting, typeset mathematics with MathJax, and executable Python statements. + +The best way to understand the notebooks is to try them out, so let's get started! + +## Launching the notebook server + +To launch the notebook server, first open up a terminal and then enter + +```Bash +jupyter notebook +``` + +This will start the notebook server. It *should* automatically open the main page of the notebook server in your default browser, but if it doesn't, simply open the browser of your choice and enter + +``` +http://localhost:8888/tree +``` + +in the address bar. + +This will bring up a simple file-browser that will show the contents of the directory where you've launched the terminal from. Click on the `New Notebook` button and then select **Python 3** at the bottom to create your first notebook. + +![newnotebook](./images/newnotebook.gif) + +## Executing a code cell + +Below the toolbars, you'll see a single code cell, prepended with `In [ ]:`. This cell can contain an arbitrarily long code segment, but we'll start with a simple one liner. In that lone code cell, type + +```Python +x = 5 +``` + +and then hit *Shift+Enter*. If you just hit Enter you'll find that it will simply add another line to the current cell. So remember, **to execute a cell**, it's **Shift+Enter**. + +So what happened? We've assigned the label x to the number 5. And also you should see that the label of that cell will now read `In[1]:` because that's the first statement we've executed in this Python kernel. You'll also notice that the notebook has created a new cell, since we already used the only existing cell. + +In this new cell, let's try to print out the value we assigned to x, so enter + + +```Python +print(x) +``` + +and then hit **Shift+Enter**. And there's the output we expect! The cell gets labeled `In[2]:` and the output of that command is printed immediately below the cell. + +The whole procedure should look something like this: + +![runandprint](./images/runandprint.gif) + +## The Kernel +Don't worry too much about what the "kernel" is, but the main point to remember here is that we can assign a variable in one cell but still access it in a separate cell. The cells are ways for *us* to divide up our thoughts and our code, but everything is connected underneath. + +## Overwriting variables + +Since each cell is interacting with the same Python instance, if we give `x` a new value and then enter `print(x)` we'll get that new value. That's pretty straight forward —but what if we then delete the cell where we gave `x` a new value? + +Let's take a look! + +![overwrite](./images/overwrite.gif) + +Even though we deleted the cell where we assigned `x = 7`, the assignment is still valid. In fact, the assignment will remain valid until we explicitly execute a cell that sets x equal to a new value, or until we completely restart this Jupyter Notebook instance. + +## Markdown +Markdown is a *writing format* that makes it easy to type well-formatted text that is rendered into properly formatted XHTML. It's seriously awesome. Cells in Jupyter notebooks can be used for many things: to run Python, to embed media, or to write text in Markdown. This allows us to write notes about what we're doing, what the code is doing, what we're *trying* to do, whatever we like! These notes can be for ourselves, to document our work, or to share with others. + +To create a Markdown cell in a notebook, click on an empty cell, then click on the Dropdown list (by default, it will say "Code") and select "Markdown"—as shown below. + +Markdown is also (sort of) code, so after you type some text, you will also hit *Shift+Enter* to execute the cell and render the Markdown text. Try it out! Just type out a sentence or two in a markdown cell, then hit *Shift+Enter* to render the text. + +![render](./images/rendermarkdown.gif) + +## Markdown Math + +Markdown can do more than just render simple text, it can also render LaTeX-style equations using **MathJax**! + +* For inline math, wrap LaTeX inside single `$` signs +`$...$` +* For single-line rendering, wrap LaTeX inside double `$$` signs +`$$...$$` + +![mathjax](./images/mathjax.gif) + +**Note:** + +Be aware that math typesetting is handled by MathJax and not by LaTeX. While the vast majority of MathJax syntax is identical to LaTeX, there are a few small differences (especially when it comes to matrix commands). So if you find something doesn't typeset the way you expect, Google around to make sure you're using the correct command. + +## More Markdown Syntax +There are several references to learn Markdown tricks, but we especially like the summary by [John Gruber](http://daringfireball.net/projects/markdown/syntax). A few features that we find particularly useful are listed below. + +For italics, wrap text in single `*`: `*this will be italic*` +For bold, wrap text in double `**`: `**this will be bold**` +For a bulleted list, start the line with an `*`, then type a space followed by the bullet item +``` +* list item +* another list item +* and another +``` + +## Moving Cells Around +You'll often find that you want to add or delete cells, or just move them around. To move a cell, just click on it to select it, then use the Up- and Down-arrows in the toolbar to change the position of the cell. + +![movecells](./images/movingcells.gif) + +To add a cell, you can click the + button in the toolbar. Once you're comfortable with the notebook layout, you can also click on Help -> Keyboard Shortcuts to find out various shortcuts for adding, deleting and managing cell position and type. diff --git a/2-finite-difference-method/lessons/00_getting_started/00_04_Intro_to_git.md b/2-finite-difference-method/lessons/00_getting_started/00_04_Intro_to_git.md new file mode 100644 index 0000000..1a1333e --- /dev/null +++ b/2-finite-difference-method/lessons/00_getting_started/00_04_Intro_to_git.md @@ -0,0 +1,321 @@ +Based heavily on [this intro](https://github.com/barbagroup/teaching-materials/blob/master/git/00-GettingStarted.md) by @anushkrish. + +# Intro to git + +Version control is a method to keep track of changes that we introduce to a set of files or documents that we use. This is especially useful when writing code because most code is written and improved through incremental changes. Version control allows us to compare newer versions of code with older versions, and investigate when certain changes were made that may have caused the code to malfunction. Git is a one such version control software, which was created by Linus Torvalds to help with writing the Linux kernel. + +Version control systems store files in a directory known as a repository. Apart from the files, a repository also contains information about the history of each file, and all the edits that were made. In this tutorial, we will learn how to create a Git repository, add files to it, make changes to those files, and record the history of those changes. + +## Before anything else +When we write commit messages (this is all coming up) we need to use a text editor. The default text editor, `vim`, is... unfriendly. It's incredibly powerful but not the way you want to start off. In light of that, let's change the default editor to the more friendly `nano` by doing the following in a terminal (we only do this once, the changes will persist): + +``` +echo "export EDITOR=nano" >> .bashrc +source .bashrc +``` + +## `git config` +Before we use Git, we have to configure two small things to help track the changes we make to files. +Please run the following two commands, filling in your personal info. Make sure to use the same email address that you used to sign up for Github. + +``` +git config --global user.email "your.github.email" +git config --global user.name "First Last" +``` + +If you copy+paste these, make sure to do it one line at a time. If you paste two lines into a terminal, it will run the first command automatically and Git will think your email address is "your.github.email". + +## Creating a `git` repository +First we are going to make a new directory that will become our first git repository. +Do you remember the command to make a new directory? It's `mkdir`! We like to keep all of our `git` directories in a folder called "git". Let's make that folder first. + +``` +mkdir git +``` + +Now let's `cd` into the `git` folder and make a new folder called "first_repo" that will be, unsurprisingly, our first repository. + +``` +cd git +mkdir first_repo +``` + +**Careful:** If you are used to using spaces in folder names, watch out! On linux (and OSX) if you run the command + +``` +mkdir first repo +``` + +You'll actually end up with *two* folders, one called `first` and one called `repo`. + +### Add a Python script to the new directory + +Let's `cd` into `first_repo` and then create a quick Python script. + +``` +cd first_repo +nano HelloWorld.py +``` + +### What's `nano`? +`nano` is a simple terminal-based text editor. There are several incredibly powerful terminal based editors (vim, emacs) but they come with pretty steep learning curves. `nano` is much friendlier. + +The file `HelloWorld.py` doesn't exist, but we run `nano HelloWorld.py` and it creates that file and opens it for editing. + +### Back to the script +Type + +```Python +print("Hello, World!") +``` + +on the first line. Then hit Ctrl+o to save the file, then Ctrl+x to exit `nano`. + +## Initializing a repository + +Now we have a folder called `first_repo` with the script `HelloWorld.py` in it. We want to convert this folder into a Git repository, which is easy! + +First, check that you are in the folder you created with `pwd`. + +``` +pwd +``` + +If you are in the right place, then run + +``` +git init +``` + +Now `first_repo` is a Git repository. + +## Repo status + +We can check the status of the repository using + +``` +git status +``` + +which will return the following: + +``` +# On branch master +# +# Initial commit +# +# Untracked files: +# (use "git add ..." to include in what will be committed) +# +# HelloWorld.py +nothing added to commit but untracked files present (use "git add" to track) +``` + +#### What's going on here? + +* The history of the repository is stored along a timeline known as a *branch*. We're on the "main" (and only) branch. +* At any point of time, the user can choose to save a snapshot of all the files in the repository. Each snapshot is referred to as a *commit*. The act of saving a snapshot is referred to as *committing changes*. + + +## Adding files to the repository + +The status command also told us that we have an "Untracked file" (`HelloWorld.py`). That means that `HelloWorld.py` isn't part of any snapshots and its history isn't being recorded by Git. + +The output also tells us what we must do to commit our changes: `(use "git add ..." to include in what will be committed)`. So let's do that, and check the status again: + +``` +git add HelloWorld.py +git status +``` + +which gives us + +``` +# On branch master +# +# Initial commit +# +# Changes to be committed: +# (use "git rm --cached ..." to unstage) +# +# new file: HelloWorld.py +# +``` + +Note that this still does not commit the changes. The `git add` command adds the file to what is known as the staging area. This is where all the changes to the files that are ready to be committed are stored. All files in the staging area are listed under "Changes to be committed:". We can see that `HelloWorld.py` has been added to this list. + +## Committing changes + +We want to save a snapshot of the repository as it is right now; it's time to commit! + +``` +git commit +``` + +This will open `nano` and you will see a bunch of information about the commit you are making. Don't worry about that too much for now, let's instead focus on writing our first commit message. Write out a commit message on the first line, something like + +``` +First commit. Add HelloWorld.py +``` + +Then hit Ctrl+o to save and then Ctrl+x to quit. + +Congratulations! You just made your first commit! Writing good commit messages is a habit you want to develop. It will help both you and anyone else who uses your code down the line. Try to follow the guidelines on [this page](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html) when writing commit messages. + + +Check the status of the repository again: + +``` +git status +``` + +and you should see + +``` +# On branch master +nothing to commit (working directory clean) +``` + +## Editing a tracked file + +Now, suppose you decide to make some changes to the file. Instead of printing "Hello world!", you want to display "Greetings Earth! We come in peace." Open `nano` again to edit the file + +``` +nano HelloWorld.py +``` + +and make the appropriate changes to the file: + +``` +print("Greetings Earth! We come in peace.") +``` + +Ctrl+o and Ctrl+x to save and quit, then check the status of the repository again + +``` +git status +``` + +You should see + +``` +# On branch master +# Changes not staged for commit: +# (use "git add ..." to update what will be committed) +# (use "git checkout -- ..." to discard changes in working directory) +# +# modified: HelloWorld.py +# +no changes added to commit (use "git add" and/or "git commit -a") +``` +You have a list of files that have been changed since the last commit, along with some tips on what you can do with them. + +## Viewing changes + +We only changed one line in one file -- you probably remember that pretty clearly at this point. But sometimes you might edit several lines, or go grab some coffee and come back, and find you can't remember everything you've done. This is where `git diff` comes in. It will show all the changes made to the current repository (even if they aren't committed yet!). Try it out! + +``` +git diff +``` + +The output will look something like this: + +``` +diff --git a/HelloWorld.py b/HelloWorld.py +index ed708ec..ce3f2ef 100644 +--- a/HelloWorld.py ++++ b/HelloWorld.py +@@ -1 +1 @@ +-print "Hello world!" ++print "Greetings Earth! We come in peace." +``` + +All the lines starting with `-` are those that have been removed, and the lines beginning with `+` are the ones that have been added. In our case, we can see that `print("Hello world!")` has been removed and `print("Greetings Earth! We come in peace.")` has been added to the file. + +## Committing changes + +We want to add the changes we made to the history of the "HelloWorld.py" file. To do this, we follow the same steps as when we first added the file. + +First, we "stage" the changes by running + +``` +git add HelloWorld.py +``` + +Now check the repo status again (you'll be typing this out LOTS): + +``` +> git status +# On branch master +# Changes to be committed: +# (use "git reset HEAD ..." to unstage) +# +# modified: HelloWorld.py +# +``` + +Now we're ready to commit that change! But it's a pretty simple change, isn't it? If we know that we don't need to write out a more complicated commit message, we can use a shortcut: + +``` +git commit -m "Edit the message to sound more friendly" +``` + +The `-m` flag is short for `message`. This command will commit the changes with the message we pass to it. No need to open `nano` this time! + +## Viewing a repo's history +We have saved two snapshots of this repository. We can look at the list of all commits using the `git log` command + +``` +git log +``` + +which will output something like + +``` +commit e9d7cbab2205d00d5ef574fcae8ff75701529565 +Author: Gil Forsyth +Date: Tue Aug 19 16:36:08 2015 -0400 + + Edit the message to sound more friendly. + +commit 16bb3d3b5af5e485e4713a3fdefcff7ae88ce7df +Author: Gil Forsyth +Date: Tue Aug 19 15:45:12 2015 -0400 + + First commit. Add HelloWorld.py. +``` + +## Uploading your repository to Github + +One of the nifty features of Git is that it allows you to copy the folder containing the repository to any other location, and all the information regarding the history of the repository is also transferred automatically. It also allows you to create a backup of your repository on a remote server. Services like Github run servers where you can host your repositories for free. + +Create an account on Github and follow the [instructions](https://help.github.com/articles/creating-a-new-repository) to create your own Github repository. + +To avoid confusion, it's a good idea to give the Github repository the same name as the folder on your computer. + +After the repository is created, Github will display instructions to push an existing repository to Github using the command line. The commands are: + +``` +git remote add origin https://github.com/gforsyth/first_repo.git +git push -u origin master +``` + +Of course, you should make the appropriate changes so it reflects your Github username and the name of your repository. + +`git remote add` is the command used to specify information about the remote repository to which you want to upload. To do this, we need to provide a name for the remote, and the address of the server where it is hosted. In the above, we name the remote repository `origin` (by convention), and specify the URL created by Github. + +`git push` is used to push all changes from the local repository to the remote repository. The `-u` flag is only used the first time you push a new branch. + +### `403 Forbidden while accessing...` +Older version of `git` will sometimes throw errors while attempting to push to GitHub or any other site that uses HTTPS authentication. If you get the above error when trying to `git push` you can fix it with one extra line: + +``` +git remote add origin https://github.com/gforsyth/first_repo.git +git remote set-url origin https://gforsyth@github.com/gforsyth/first_repo.git +git push -u origin master +``` + +Make sure to change the username and repository name to match what you have created. If you are using an older version of `git`, the easiest solution is to upgrade, but if you can't for whatever reason, then running that extra command when you set up a new repository should fix the issue. + +## Look at your repo on Github +Your changes should be reflected immediately on Github. The URL for your repo should be `https://github.com//first_repo`. Take a look around. You can look at the file(s) you pushed and also look at the commit history of your repository. diff --git a/2-finite-difference-method/lessons/00_getting_started/images/1.whoami.gif b/2-finite-difference-method/lessons/00_getting_started/images/1.whoami.gif new file mode 100644 index 0000000..bb56136 Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/1.whoami.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/2.pwd.gif b/2-finite-difference-method/lessons/00_getting_started/images/2.pwd.gif new file mode 100644 index 0000000..a5fda02 Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/2.pwd.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/3.ls.gif b/2-finite-difference-method/lessons/00_getting_started/images/3.ls.gif new file mode 100644 index 0000000..1023750 Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/3.ls.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/4.cd.gif b/2-finite-difference-method/lessons/00_getting_started/images/4.cd.gif new file mode 100644 index 0000000..c5ab8f4 Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/4.cd.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/5.cdtabtab.gif b/2-finite-difference-method/lessons/00_getting_started/images/5.cdtabtab.gif new file mode 100644 index 0000000..2b3498e Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/5.cdtabtab.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/6.bashrc.gif b/2-finite-difference-method/lessons/00_getting_started/images/6.bashrc.gif new file mode 100644 index 0000000..ba322bf Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/6.bashrc.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/addtopath.gif b/2-finite-difference-method/lessons/00_getting_started/images/addtopath.gif new file mode 100644 index 0000000..9947692 Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/addtopath.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/anaconda.download.gif b/2-finite-difference-method/lessons/00_getting_started/images/anaconda.download.gif new file mode 100644 index 0000000..4e57414 Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/anaconda.download.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/condainstall.gif b/2-finite-difference-method/lessons/00_getting_started/images/condainstall.gif new file mode 100644 index 0000000..d099f7a Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/condainstall.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/mathjax.gif b/2-finite-difference-method/lessons/00_getting_started/images/mathjax.gif new file mode 100644 index 0000000..1fe3d43 Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/mathjax.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/movingcells.gif b/2-finite-difference-method/lessons/00_getting_started/images/movingcells.gif new file mode 100644 index 0000000..f5a276e Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/movingcells.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/newnotebook.gif b/2-finite-difference-method/lessons/00_getting_started/images/newnotebook.gif new file mode 100644 index 0000000..37369b7 Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/newnotebook.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/overwrite.gif b/2-finite-difference-method/lessons/00_getting_started/images/overwrite.gif new file mode 100644 index 0000000..25860df Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/overwrite.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/rendermarkdown.gif b/2-finite-difference-method/lessons/00_getting_started/images/rendermarkdown.gif new file mode 100644 index 0000000..66c995b Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/rendermarkdown.gif differ diff --git a/2-finite-difference-method/lessons/00_getting_started/images/runandprint.gif b/2-finite-difference-method/lessons/00_getting_started/images/runandprint.gif new file mode 100644 index 0000000..41fff89 Binary files /dev/null and b/2-finite-difference-method/lessons/00_getting_started/images/runandprint.gif differ diff --git a/2-finite-difference-method/lessons/01_phugoid/01_01_Phugoid_Theory.ipynb b/2-finite-difference-method/lessons/01_phugoid/01_01_Phugoid_Theory.ipynb new file mode 100644 index 0000000..82ee6bb --- /dev/null +++ b/2-finite-difference-method/lessons/01_phugoid/01_01_Phugoid_Theory.ipynb @@ -0,0 +1,798 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, C. Cooper, G.F. Forsyth, A. Krishnan." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Phugoid Motion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome to [**\"Practical Numerical Methods with Python!\"**](http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/about) This course is a collaborative, online, open education project, where we aim to give a foundation in scientific computing. The focus is on numerical solution of problems modeled by ordinary and partial differential equations.\n", + "\n", + "This Jupyter Notebook introduces the problem we'll be studying in the **first module** of the course: the _phugoid model of glider flight_. We'll start with some background, explaining the physics, and working out the mathematical model. \n", + "\n", + "First, we'll look at an idealized motion where there is no drag, resulting in a simple harmonic motion. We can plot some interesting trajectories that will pique your imagination. In the next notebook, you'll learn to numerically integrate the differential equation using Euler's method. But hang on ... first things first. \n", + "\n", + "The term \"phugoid\" is used in aeronautics to refer to a motion pattern where an aircraft oscillates up and down —nose-up and climb, then nose-down and descend— around an equilibrium trajectory. The aircraft oscillates in altitude, speed and pitch, with only small (neglected) variations in the angle of attack, as it repeatedly exchanges kinetic and potential energy.\n", + "\n", + "A low-amplitude phugoid motion can be just a nuisance, as the aircraft does not exceed the stall angle of attack and nothing bad happens. But the mode can also be unstable leading to a stall or even a loop!\n", + "\n", + "Look at this video showing a Cessna single-engine airplane in phugoid motion:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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\n", + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import YouTubeVideo\n", + "YouTubeVideo('ysdU4mnRYdM')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That doesn't look too good! What's happening? \n", + "\n", + "It can get a lot worse when an aircraft enters one of these modes that is unstable. For example, one of [NASA's Helios Solar Powered Aircraft](http://www.nasa.gov/centers/dryden/history/pastprojects/Helios/) prototype broke up in mid air due to extreme phugoid oscillations!\n", + "\n", + "Helios was a proof-of-concept solar electric-powered flying wing that broke the world altitude record for a non-rocket-powered aircraft in August 2001. But in June 26, 2003, it broke something else. The aircraft entered phugoid motion after encountering turbulence near the Hawaiian Island of Kauai. The high speed in the oscillatory movement exceeded the design limits, and it ended up wrecked in the Pacific Ocean. Luckily, the Helios was remotely operated, and nobody got hurt." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The physics of phugoids" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The phugoid oscillation has the aircraft pitching up and down, as it decelerates and accelerates. The trajectory might look like a sinusoid, as in the figure below. The assumption is that the forward velocity of the aircraft, $v$, varies in such a way that the angle of attack remains (nearly) constant, which means that we can assume a constant lift coefficient." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Image](./figures/oscillatory_trajectory.png)\n", + "#### Figure 1. Trajectory of an aircraft in phugoid motion." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the descending portion of the trajectory, the aircraft's velocity increases as it proceeds from a peak to the minimum height—gaining kinetic energy at the expense of potential energy. The contrary happens in the upward segment, as its velocity decreases there.\n", + "\n", + "We measure the pitch angle (between the aircraft's longitudinal axis and the horizontal) as positive when the aircraft's nose is pointing up. In the portion of the trajectory below the center-line, where it curves upwards, the pitch angle $\\theta$ is increasing: $\\dot{\\theta}>0$. And where the trajectory curves down, the pitch angle is decreasing: $\\dot{\\theta}<0$, as shown in the figure.\n", + "\n", + "Let's remind ourselves of the forces affecting an aircraft in a downward glide. Look at the figure below: we show the flight path, the forces on the glider (no thrust), and the _glide angle_ or flight path angle, $\\gamma$, between the flight path and the horizontal." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Image](./figures/glider_forces.png)\n", + "#### Figure 2. Forces on a glider." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The force of lift, $L$ —created by the airflow around the wings— is perpendicular to the trajectory, and the force of drag, $D$, is parallel to the trajectory. Both forces are expressed in terms of coefficients of lift and drag, $C_L$ and $C_D$, respectively, that depend on the wing design and _angle of attack_—the angle between the wing chord and the flight path.\n", + "\n", + "If you are not familiar with airplane aerodynamics, you might be getting confused with some terms here ... and all those angles! But be patient and look things up, if you need to. We're giving you a quick summary here.\n", + "\n", + "Lift and drag are proportional to a surface area, $S$, and the dynamic pressure: $1/2 \\rho v^2$, where $\\rho$ is the density of air, and $v$ the forward velocity of the aircraft. The equations for lift and drag are:\n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "L &=& C_L S \\times \\frac{1}{2} \\rho v^2 \\\\\n", + "D &=& C_D S \\times \\frac{1}{2} \\rho v^2\n", + "\\end{eqnarray}\n", + "$$\n", + "\n", + "If the glider were in equilibrium, the forces would balance each other. We can equate the forces in the directions perpendicular and parallel to the trajectory, as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "L = W \\cos \\gamma \\quad \\text{and} \\quad D = W \\sin \\gamma\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $W$ represents the weight of the glider.\n", + "\n", + "In the figure, we've drawn the angle $\\gamma$ as the _glide angle_, formed between the direction of motion and the horizontal. We are not bothered with the _sign_ of the angle, because we draw a free-body diagram and take the direction of the forces into account in writing our balance equations. But later on, we will need to be careful with the sign of the angles. It can cause you a real headache to keep this straight, so be patient!\n", + "\n", + "It looks like we've set this up to do a little bit of mathematics. Are you ready?\n", + "\n", + "But before, a short glimpse of the history." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lanchester's Aerodonetics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Phugoid theory\" was first described by the British engineer Frederick W. Lanchester in _\"Aerodonetics\"_ (1909). This book is so old that it is now in the public domain, so you can actually download [from Google Books](http://books.google.com/books?id=6hxDAAAAIAAJ&dq=%22phugoid%20theory%20deals%20with%20the%20longitudinal%20stability%22&pg=PA37#v=onepage&q=%22phugoid%20theory%20deals%20with%20the%20longitudinal%20stability%22&f=false) a PDF file of a scan, or read it online. \n", + "\n", + "Lanchester defines phugoid theory as the study of longitudinal stability of a flying machine (aerodone). He first considered the simplification where drag and moment of inertia are neglected. Then he included these effects, obtaining an equation of stability. In addition to describing many experiments by himself and others, Lanchester also reports on _\"numerical work ... done by the aid of an ordinary 25-cm slide rule.\"_ Go figure!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ideal case of zero drag" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section, we follow the derivation given by Milne-Thompson (1966), which we find a little bit easier than that of the original in \"Aerodonetics\"!\n", + "\n", + "An aircraft flying in a steady, straight horizontal flight has a lift equal to its weight. The velocity in this condition is sometimes called _trim velocity_ (\"trim\" is what pilots do to set the controls to just stay in a steady flight). Let's use $v_t$ for the trim velocity, and from $L=W$ deduce that:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "W = C_L S \\times\\frac{1}{2} \\rho v_t^2\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The weight $W$ is constant for the aircraft, but the lift at any other flight condition depends on the flight speed, $v$. We can use the expression for the weight in terms of $v_t$ to obtain the ratio $L/W$ at any other flight velocity, as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{L}{W}= \\frac{v^2}{v_t^2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Imagine that the aircraft experienced a little upset, a wind gust, and it finds itself off the \"trim\" level, in a curved path with an instantaneous angle $\\theta$. In the sketch below, we exaggerate the curved trajectory of flight to help you visualize what we'll do next. The angle $\\theta$ (using the same name as Milne-Thompson) is between the _trajectory_ and the horizontal, positive up." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "#### Figure 3. Curved trajectory of the aircraft going up." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can form a free body diagram to determine the balance of forces. \n", + "\n", + "\n", + "\n", + "#### Figure 4. Free body diagram of the aircraft trajectory" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the free body diagram, we can see that\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\vec{L} + \\vec{W} = m\\vec{a} = \\frac{mv^2}{R}\\hat{n} + m \\frac{dv}{dt}\\hat{t}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $\\frac{v^2}{R}$ is the centripetal acceleration and $R$ is the radius of curvature of the trajectory.\n", + "If we decompose the lift and weight into their normal and tangential components we get\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "L\\hat{n} + W_n\\hat{n} + W_t\\hat{t} = \\frac{mv^2}{R}\\hat{n} + m \\frac{dv}{dt}\\hat{t}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The component of the weight in the normal direction ($W_n$) is\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "W_n = -W \\cos \\theta\n", + "\\end{equation}\n", + "$$\n", + "\n", + "If we then consider that all of the components in $\\hat{n}$ must balance out, we arrive at\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "L - W \\cos \\theta = \\frac{mv^2}{R}\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can rewrite this as\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "L- W \\cos \\theta = \\frac{W}{g} \\frac{v^2}{R}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $g$ is the acceleration due to gravity. Rearrange this by dividing the equation by the weight, and use the expression we found for $L/W$, above. The following equation results:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{v^2}{v_t^2}-\\cos \\theta = \\frac{v^2}{g R}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Recall that we simplified the problem assuming that there is no friction, which means that the total energy is constant (the lift does no work). If $z$ represents the depth below a reference horizontal line, the energy per unit mass is (kinetic plus potential energy):\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{1}{2}v^2-g z = \\text{constant}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "To get rid of that pesky constant, we can choose the reference horizontal line at the level that makes the constant energy equal to zero, so $v^2 = 2 g z$. That helps us re-write the phugoid equation in terms of $z$ as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{z}{z_t}-\\cos \\theta = \\frac{2z}{R}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Let $ds$ represent a small arc-length of the trajectory. We can write \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{1}{R} = \\frac{d\\theta}{ds} \\quad \\text{and}\\quad \\sin\\theta = -\\frac{dz}{ds}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Employing the chain rule of calculus,\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{1}{R} = \\frac{d\\theta}{ds} = \\frac{dz}{ds}\\frac{d\\theta}{dz} = -\\sin \\theta\\frac{d\\theta}{dz}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Multiply the phugoid equation by $\\frac{1}{2\\sqrt{z}}$ to get:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\sqrt{z}}{2z_t} - \\frac{\\cos\\theta}{2\\sqrt{z}} = \\frac{\\sqrt{z}}{R}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Substituting for $1/R$ on the right hand side and bringing the cosine term over to the right, we get:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\sqrt{z}}{2z_t} = \\frac{\\cos \\theta}{2 \\sqrt{z}} - \\sqrt{z} \\sin \\theta \\frac{d\\theta}{dz}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The right-hand-side is an exact derivative! We can rewrite it as:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{d}{dz} \\left(\\sqrt{z}\\cos\\theta \\right) = \\frac{\\sqrt{z}}{2z_t}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Integrating this equation, we add an arbitrary constant, chosen as $C\\sqrt{z_t}$ which (after dividing through by $\\sqrt{z}$) gives:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\cos \\theta = \\frac{1}{3}\\frac{z}{z_t} + C\\sqrt{\\frac{z_t}{z}}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Taking the derivative of both sides of equation (19) and applying the relations from equation (15) yields:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{z_t}{R} = \\frac{1}{3} - \\frac{C}{2}\\sqrt{\\frac{z_t^3}{z^3}}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Make sure you have followed the derivation, and perhaps write it out on paper!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Phugoid Curves" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Equation (15) is non-linear, which usually means we are hard-pressed to write a clean expression for the variable of interest, $z$. In fact, Lanchester himself said that he was unable to _\"reduce this expression to a form suitable for co-ordinate plotting.\"_ If the great polymath couldn't do it, we can't either!\n", + "\n", + "But Lanchester _was_ able to plot a suitable approximation of the phugoid flight path using what he called the \"trammel\" method. If you're interested in seeing how he did it, his explanation begins on page [48 of Aerodonetics](http://books.google.com/books?id=6hxDAAAAIAAJ&pg=PA49&lpg=PA48&dq=aerodonetics+the+use+of+the+trammel&source=bl&ots=lB6EVKYQuT&sig=aVE2kiDWZoWftaWczMIrcYftMOs&hl=en&sa=X&ei=gTD_U82fGYjzgwT3moGwCQ&ved=0CCAQ6AEwAA#v=onepage&q=aerodonetics%20the%20use%20of%20the%20trammel&f=false). It's a trip.\n", + "\n", + "Lanchester used Equations (15) and (16) to solve for the constant $C$ and the radius of curvature $R$ and then iteratively plotted small arcs of the phugoid path. By hand.\n", + "\n", + "We wrote a neat little code that duplicates the manual trammel method, but it might be a bit much for you to absorb in the first lesson. If you want to look it over, you are more than welcome to. If you are just starting with Python, skip it for the moment and we'll return to it at the end of this module. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting the flight path" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we mentioned, we wrote a Python code to reproduce programmatically what Lanchester did graphically. Here's a neat feature of Jupyter Notebooks: you can run external programs with the magical keyword ... wait for it ... `run`. And the jargon of Jupyter _is_ to call this \"magic.\" In fact, there are a bunch of [magic functions](https://ipython.readthedocs.io/en/stable/interactive/index.html) that you will learn about. They will make you a happy camper.\n", + "The line `%matplotlib inline` tells Jupyter Notebook to show the plots inline.\n", + "\n", + "Let's do it:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%run phugoid.py\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This code cell loaded our simulated-trammel code, `phugoid.py`. The code defined a function for you in the background, called `plot_flight_path`, taking three positional inputs: $z_t$, $z$ and $\\theta$. \n", + "\n", + "Look again at Equation (15), where we take the positive square root. There are several possibilities, depending on the value that the constant $C$ takes. \n", + "\n", + "* There are no physical solutions for $C>2/3$, because it would result in $\\cos\\theta>1$. \n", + "\n", + "* If $C=2/3$, then the solution is a horizontal straight line, because $\\cos\\theta=1$, $\\theta=0$ and $R=\\infty$.\n", + "\n", + "* Any value of $C$ for which $0 < C < \\frac{2}{3}$ will produce \"trochoidal\"-like paths. What does this look like? Let's use our custom function `plot_flight_path` to find out!" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initial conditions: zt = 64.0, z0 = 16.0, theta0 = 0.0.\n", + "plot_flight_path(64.0, 16.0, 0.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cool! Note that the plot title tells us what the calculated value of $C$ was for our input conditions. We have a value of $C$ between $0$ and $\\frac{2}{3}$ and our path is trochoidal, like we announced it would be.\n", + "\n", + "* For negative values of $C$, the resultant flight path consists of a series of loops. Let's try it out!" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initial conditions: zt = 64.0, z0 = 16.0, theta0 = 180.0.\n", + "plot_flight_path(64.0, 16.0, 180.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can play around with the input values and see what kind of behavior results. Just note that any value of $C > \\frac{2}{3}$ will result in $\\cos \\theta > 1$, which doesn't exist. Python will probably throw a few errors if you hit that condition, but just try again!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* The last case is $C = 0$. Take another look at Equation (16) and plug in $C = 0$, what should happen? It looks like it will just reduce to \n", + "\n", + "$$R = 3z_t$$\n", + "\n", + "It's a constant radius of curvature! In fact, this solution is a series of semi-circles, with a cusp between them. One way to force $C = 0$ that we can figure out from Equation (15), is to make:\n", + "\n", + "\n", + "$$z = 3z_t, \\quad \\theta = 0$$" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initial conditions: zt = 16.0, z0 = 48.0, theta0 = 0.0.\n", + "plot_flight_path(16.0, 48.0, 0.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That looks an awful lot like a quarter circle. And what's the radius of the arc? It's $r = 48 = 3z_t$.\n", + "\n", + "We can also get a semi-circle out of our simulated trammel by changing to another configuration where $C$ is (near) zero. Here's one example:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initial conditions: zt = 64.0, z0 = 16.0, theta0 = -90.0.\n", + "plot_flight_path(64.0, 16.0, -90.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That is so nice. We have reproduced the trajectories that Lanchester found more than a hundred years ago, painstakingly drawing them by hand with a contraption called a \"trammel.\" It must have taken him days!\n", + "\n", + "Here is how the different phugoid curves are drawn in von Kármán's book, _Aerodynamics_ (1957). He never says _how_ he drew them, but we're guessing by hand, also. We did pretty good!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Image](./figures/vonKarman-phugoids.png)\n", + "\n", + "#### Figure 4. Phugoid curves in von Kármán (1957)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the [next notebook](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_02_Phugoid_Oscillation.ipynb) of this series, we'll look at the differential equation that arises when you consider small perturbations on the horizontal phugoid, and we'll learn to numerically integrate that to get the flight paths." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Lanchester, F. W. _Aerodonetics_, D. van Nostrand Company: New York, 1909. On the public domain. [Get it from Google Books](http://books.google.com/books?id=6hxDAAAAIAAJ&pg=PP1#v=onepage&q&f=false).\n", + "\n", + "2. Milne-Thompson, L. M. _Theoretical Aerodynamics_, Dover 2012 reprint of the revised 1966 edition. [Read on Google Books](http://books.google.com/books?id=EMfCAgAAQBAJ&lpg=PP1&pg=PP1#v=onepage&q&f=false) (see section 18.5)\n", + "\n", + "3. Sinha, N. K. and Ananthkrishnan, N. _Elementary Flight Dynamics with an introduction to Bifurcation and Continuation Methods_, CRC Press, 2013. [Read on Google Books](http://books.google.com/books?id=yXL6AQAAQBAJ&lpg=PP1&pg=PP1#v=onepage&q&f=false) (see chapter 5)\n", + "\n", + "4. von Kármán, T. _Aerodynamics_, Dover 2004 reprint of the 1957 2nd edition. (see pages 149–151)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of this notebook. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute this cell to load the notebook's style sheet, then ignore it.\n", + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/01_phugoid/01_02_Phugoid_Oscillation.ipynb b/2-finite-difference-method/lessons/01_phugoid/01_02_Phugoid_Oscillation.ipynb new file mode 100644 index 0000000..dbf20a9 --- /dev/null +++ b/2-finite-difference-method/lessons/01_phugoid/01_02_Phugoid_Oscillation.ipynb @@ -0,0 +1,990 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth. Partly based on David Ketcheson's pendulum lesson, also under CC-BY." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Phugoid Oscillation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome back! This is the second Jupyter Notebook of the series _\"The phugoid model of glider flight\"_, the first learning module of the course [**\"Practical Numerical Methods with Python.\"**](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/info)\n", + "\n", + "In the [first notebook](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_01_Phugoid_Theory.ipynb), _\"Phugoid Motion\"_, we described the physics of an aircraft's oscillatory trajectory, seen as an exchange of kinetic and potential energy. This analysis goes back to Frederick Lanchester, who published his book _\"Aerodonetics\"_ on aircraft stability in 1909. We concluded that first exposure to our problem of interest by plotting the flight paths predicted by Lanchester's analysis, known as _phugoids_.\n", + "\n", + "Here, we will look at the situation when an aircraft is initially moving on the straight-line phugoid (obtained with the parameters $C=2/3$, $\\cos\\theta=1$, and $z=z_t$ in the previous analysis), and experiences a small upset, a wind gust that slightly perturbs its path. It will then enter into a gentle oscillation around the previous straight-line path: a _phugoid oscillation_.\n", + "\n", + "If the aircraft experiences an upward acceleration of $-d^2z/dt^2$, and we assume that the perturbation is small, then $\\cos\\theta=1$ is a good approximation and Newton's second law in the vertical direction is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "L - W = - \\frac{W}{g}\\frac{d^2 z}{dt^2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "In the previous notebook, we saw that the following relation holds for the ratio of lift to weight, in terms of the trim velocity $v_t$:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{L}{W}=\\frac{v^2}{v_t^2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This will be useful: we can divide Equation (1) by the weight and use Equation (2) to replace $L/W$. Another useful relation from the previous notebook expressed the conservation of energy (per unit mass) as $v^2 = 2 gz$. With this, Equation (1) is rearranged as:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{d^2z}{dt^2} + \\frac{gz}{z_t} = g\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Look at Equation (3) for a moment. Does it ring a bell? Do you recognize it?\n", + "\n", + "If you remember from your physics courses the equation for _simple harmonic motion_, you should see the similarity! \n", + "\n", + "Take the case of a simple spring. Hooke's law is $F=-kx$, where $F$ is a restoring force, $x$ the displacement from a position of equilibrium and $k$ the spring constant. This results in the following ordinary differential equation for the displacement:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\frac{d^2 x}{dt^2}= -\\frac{k}{m}x\n", + "\\end{equation}\n", + "$$\n", + "\n", + "which has the solution $x(t) = A \\cos(\\omega t- \\phi)$, representing simple harmonic motion with an angular frequency $\\omega=\\sqrt{k/m}=2\\pi f$ and phase angle $\\phi$.\n", + "\n", + "Now look back at Equation (3): it has nearly the same form and it represents simple harmonic motion with angular frequency $\\omega=\\sqrt{g/z_t}$ around mean height $z_t$. \n", + "\n", + "Think about this for a moment ... we can immediately say what the period of the oscillation is: exactly $2 \\pi \\sqrt{z_t/g}$ — or, in terms of the trim velocity, $\\pi \\sqrt{2} v_t/g$.\n", + "\n", + "_This is a remarkable result!_ Think about it: we know nothing about the aircraft, or the flight altitude, yet we can obtain the period of the phugoid oscillation simply as a function of the trim velocity. For example, if trim velocity is 200 knots, we get a phugoid period of about 47 seconds—over that time, you really would not notice anything if you were flying in that aircraft.\n", + "\n", + "Next, we want to be able to compute the trajectory of the aircraft for a given initial perturbation. We will do this by numerically integrating the equation of motion." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prepare to integrate" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We want to integrate the differential equation and plot the trajectory of the aircraft. Are you ready?\n", + "\n", + "The equation for the phugoid oscillation is a second-order, ordinary differential equation (ODE). Let's represent the time derivative with a prime, and write it like this:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "z(t)'' + \\frac{g \\,z(t)}{z_t}=g\n", + "\\end{equation}\n", + "$$\n", + "\n", + "There's a convenient trick when we work with ODEs: we can turn this 2nd-order equation into a system of two 1st-order equations. Like this:\n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "z'(t) &=& b(t)\\\\\n", + "b'(t) &=& g\\left(1-\\frac{z(t)}{z_t}\\right)\n", + "\\end{eqnarray}\n", + "$$\n", + "\n", + "Are you following? Make sure you are following the derivations, even if it means writing the equations down in your own notes! (Yes, the old-fashioned paper way.)\n", + "\n", + "Another way to look at a system of two 1st-order ODEs is by using vectors. You can make a vector with your two independent variables, \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\vec{u} = \\begin{pmatrix} z \\\\ b \\end{pmatrix}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "and write the differential system as a single vector equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\vec{u}'(t) = \\begin{pmatrix} b\\\\ g-g\\frac{z(t)}{z_t} \\end{pmatrix}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "If you call the right-hand-side $\\vec{f}(\\vec{u})$, then the equation is very short: $\\vec{u}'(t) = \\vec{f}(\\vec{u})$—but let's drop those arrows to denote vectors from now on, as they are a bit cumbersome: just remember that $u$ and $f$ are vectors in the phugoid equation of motion.\n", + "\n", + "Next, we'll prepare to solve this problem numerically." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initial value problems" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's step back for a moment. Suppose we have a first-order ODE $u'=f(u)$. You know that if we were to integrate this, there would be an arbitrary constant of integration. To find its value, we do need to know one point on the curve $(t, u)$. When the derivative in the ODE is with respect to time, we call that point the _initial value_ and write something like this:\n", + "\n", + "$$\n", + "u(t=0)=u_0\n", + "$$\n", + "\n", + "In the case of a second-order ODE, we already saw how to write it as a system of first-order ODEs, and we would need an initial value for each equation: two conditions are needed to determine our constants of integration. The same applies for higher-order ODEs: if it is of order $n$, we can write it as $n$ first-order equations, and we need $n$ known values. If we have that data, we call the problem an _initial value problem_.\n", + "\n", + "Remember the definition of a derivative? The derivative represents the slope of the tangent at a point of the curve $u=u(t)$, and the definition of the derivative $u'$ for a function is:\n", + "\n", + "$$\n", + "u'(t) = \\lim_{\\Delta t\\rightarrow 0} \\frac{u(t+\\Delta t)-u(t)}{\\Delta t}\n", + "$$\n", + "\n", + "If the step $\\Delta t$ is already very small, we can _approximate_ the derivative by dropping the limit. We can write:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u(t+\\Delta t) \\approx u(t) + u'(t) \\Delta t\n", + "\\end{equation}\n", + "$$\n", + "\n", + "With this equation, and because we know $u'(t)=f(u)$, if we have an initial value, we can step by $\\Delta t$ and find the value of $u(t+\\Delta t)$, then we can take this value, and find $u(t+2\\Delta t)$, and so on: we say that we _step in time_, numerically finding the solution $u(t)$ for a range of values: $t_1, t_2, t_3 \\cdots$, each separated by $\\Delta t$. The numerical solution of the ODE is simply the table of values $t_i, u_i$ that results from this process." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discretization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to execute the process described above and find the numerical solution of the ODE, we start by choosing the values $t_1,t_2,t_3 \\cdots t_n$—we call these values our *grid* in time. The first point of the grid is given by our _initial value_, and the small difference between two consecutive times is called the _time step_, denoted by $\\Delta t$. The solution value at time $t_n$ is denoted by $u_n$.\n", + "\n", + "Let's build a time grid for our problem. We first choose a final time $T$ and the time step $\\Delta t$. In code, we'll use readily identifiable variable names: `T` and `dt`, respectively. With those values set, we can calculate the number of time steps that will be needed to reach the final time; we call that variable `N`. \n", + "\n", + "Let's write some code. The first thing we do in Python is load our favorite libraries: NumPy for array operations, and the Pyplot module in Matplotlib, to later on be able to plot the numerical solution. The line `%matplotlib inline` tells Jupyter Notebook to show the plots inline." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy \n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, initialize `T` and `dt`, calculate `N` and build a NumPy array with all the values of time that make up the grid." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Create the time grid.\n", + "T = 100.0 # length of the time-interval\n", + "dt = 0.02 # time-step size\n", + "N = int(T / dt) + 1 # number of time steps\n", + "t = numpy.linspace(0.0, T, num=N) # time grid" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have our grid! Now it's time to apply the numerical time stepping represented by Equation (10)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Challenge!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Write the code above using the NumPy function `arange()` instead of `linspace()`. If you need to, read the documentation for these functions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Pro tip:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Enter a question mark followed by any function, e.g., `?numpy.linspace`, into a code cell and execute it, to get a help pane on the notebook." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Euler's method" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The approximate solution at time $t_n$ is $u_n$, and the numerical solution of the differential equation consists of computing a sequence of approximate solutions by the following formula, based on Equation (10):\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u_{n+1} = u_n + \\Delta t \\,f(u_n)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This formula is called **Euler's method**.\n", + "\n", + "For the equations of the phugoid oscillation, Euler's method gives the following algorithm that we need to implement in code:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "z_{n+1} & = z_n + \\Delta t \\, b_n \\\\\n", + "b_{n+1} & = b_n + \\Delta t \\left(g - \\frac{g}{z_t} \\, z_n \\right)\n", + "\\end{align}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### And solve!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To apply the numerical solution method, we need to set things up in code: define the parameter values needed in the model, initialize a NumPy array to hold the discrete solution values, and initialize another array for the elevation values." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the initial conditions.\n", + "z0 = 100.0 # altitude\n", + "b0 = 10.0 # upward velocity resulting from gust\n", + "zt = 100.0 # trim altitude\n", + "g = 9.81 # acceleration due to gravity\n", + "\n", + "# Set the initial value of the numerical solution.\n", + "u = numpy.array([z0, b0])\n", + "\n", + "# Create an array to store the elevation value at each time step.\n", + "z = numpy.zeros(N)\n", + "z[0] = z0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You should pay attention to a couple of things: (1) See how there is a dot after the numbers used to define our parameters? We just want to be explicit (as a good habit) that these variables are real numbers, called \"floats.\" (2) We both _created_ and _initialized_ with zeros everywhere the solution vector `z`. Look up the documentation for the handy NumPy function `zeros()`, if you need to. (3) In the last line above, we assign the _initial value_ to the first element of the solution vector: `z[0]`.\n", + "\n", + "Now we can step in time using Euler's method. Notice how we are time stepping the two independent variables at once in the time iterations." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Temporal integration using Euler's method.\n", + "for n in range(1, N):\n", + " rhs = numpy.array([u[1], g * (1 - u[0] / zt)])\n", + " u = u + dt * rhs\n", + " z[n] = u[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Make sure you understand what this code is doing. This is a basic pattern in numerical methods: iterations in a time variable that apply a numerical scheme at each step." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot the solution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If the code is correct, we have stored in the array `z` the position of the glider at each time. Let's use Matplotlib to examine the flight path of the aircraft.\n", + "\n", + "You should explore the [Matplotlib tutorial](https://matplotlib.org/users/pyplot_tutorial.html) (if you need to) and familiarize yourself with the command-style functions that control the size, labels, line style, and so on. Creating good plots is a useful skill: it is about communicating your results effectively. \n", + "\n", + "Here, we set the figure size, the limits of the vertical axis, the format of tick-marks, and axis labels. The final line actually produces the plot, with our chosen line style (continuous black line)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16\n", + "\n", + "# Plot the solution of the elevation.\n", + "pyplot.figure(figsize=(9.0, 4.0)) # set the size of the figure\n", + "pyplot.title('Elevation of the phugoid over the time') # set the title\n", + "pyplot.xlabel('Time [s]') # set the x-axis label\n", + "pyplot.ylabel('Elevation [m]') # set the y-axis label\n", + "pyplot.xlim(t[0], t[-1]) # set the x-axis limits\n", + "pyplot.ylim(40.0, 160.0) # set the y-axis limits\n", + "pyplot.grid() # set a background grid to improve readability\n", + "pyplot.plot(t, z, color='C0', linestyle='-', linewidth=2);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Explore and think" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Try changing the value of `v` in the initial conditions. \n", + "\n", + "* What happens when you have a larger gust? \n", + "* What about a smaller gust? \n", + "* What happens if there isn't a gust (`v = 0`)?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exact solution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The equation for phugoid oscillations is a 2nd-order, linear ODE and it has an exact solution of the following form:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "z(t) = A \\sin \\left(\\sqrt{\\frac{g}{z_t}} t \\right) + B \\cos \\left(\\sqrt{\\frac{g}{z_t}} t \\right) + z_t\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $A$ and $B$ are constants that we solve for using initial conditions. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our numerical solution used the initial conditions:\n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "z(0) = z_0 \\\\\n", + "b(0) = b_0\n", + "\\end{eqnarray}\n", + "$$\n", + "\n", + "Applying these to the exact solution and solving for $A$ and $B$, we get:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "z(t) = b_0 \\sqrt{\\frac{z_t}{g}} \\sin \\left(\\sqrt{\\frac{g}{z_t}} t \\right) + (z_0-z_t) \\cos \\left(\\sqrt{\\frac{g}{z_t}} t \\right) + z_t\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We already defined all of these variables for our numerical solution, so we can immediately compute the exact solution. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Pro tip:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The expression is a bit long —if you don't feel like scrolling left and right, you can cast the value of the variable between parenthesis and insert line breaks and Python will treat the next line as a continuation of the first." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "z_exact = (b0 * (zt / g)**0.5 * numpy.sin((g / zt)**0.5 * t) +\n", + " (z0 - zt) * numpy.cos((g / zt)**0.5 * t) + zt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot the exact solution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can plot our exact solution! Even better, we can plot _both_ the numerical solution *and* the exact solution to see how well Euler's method approximated the phugoid oscillations.\n", + "\n", + "To add another curve to a plot, simply type a second `pyplot.plot()` statement. We also add a legend using `pyplot.legend()`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the numerical solution and the exact solution.\n", + "pyplot.figure(figsize=(9.0, 4.0)) # set the size of the figure\n", + "pyplot.title('Elevation of the phugoid over the time') # set the title\n", + "pyplot.xlabel('Time [s]') # set the x-axis label\n", + "pyplot.ylabel('Elevation [m]') # set the y-axis label\n", + "pyplot.xlim(t[0], t[-1]) # set the x-axis limits\n", + "pyplot.ylim(40.0, 160.0) # set the y-axis limits\n", + "pyplot.grid() # set a background grid to improve readability\n", + "pyplot.plot(t, z, label='Numerical',\n", + " color='C0', linestyle='-', linewidth=2)\n", + "pyplot.plot(t, z_exact, label='Analytical',\n", + " color='C1', linestyle='-', linewidth=2)\n", + "pyplot.legend(); # set the legend" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That looks like pretty good agreement, but what's happening towards the end? We'll come back to this. For now, re-run the previous steps with a different time step, say $dt=0.01$ and pay attention to the difference.\n", + "\n", + "Euler's method, like all numerical methods, introduces some errors. If the method is *convergent*, the approximation will get closer and closer to the exact solution as we reduce the size of the step, $\\Delta t$. The error in the numerical method should tend to zero, in fact, when $\\Delta t\\rightarrow 0$—when this happens, we call the method _consistent_. We'll define these terms more carefully in the theory components of this course. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Convergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To compare the two solutions, we need to use a **norm** of the difference, like the $L_1$ norm, for example.\n", + "\n", + "$$\n", + "E = \\Delta t \\sum_{n=0}^N \\left|z(t_n) - z_n\\right|\n", + "$$\n", + "\n", + "The $L_1$ norm is the sum of the individual differences between the exact and the numerical solutions, at each mesh point. In other words, $E$ is the discrete representation of the integral over the interval $T$ of the (absolute) difference between the computed $z$ and $z_{\\rm exact}$:\n", + "\n", + "$$\n", + "E = \\int \\vert z-z_\\rm{exact}\\vert dt\n", + "$$\n", + "\n", + "We check for convergence by calculating the numerical solution using progressively smaller values of `dt`. We already have most of the code that we need. We just need to add an extra loop and an array of different $\\Delta t$ values to iterate through." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Warning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The cell below can take a little while to finish (the last $\\Delta t$ value alone requires 1 million iterations!). If the cell is still running, the input label will say `In [*]`. When it finishes, the `*` will be replaced by a number." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the list of time-step sizes.\n", + "dt_values = [0.1, 0.05, 0.01, 0.005, 0.001, 0.0001]\n", + "\n", + "# Create an empty list that will contain the solution of each grid.\n", + "z_values = []\n", + "\n", + "for dt in dt_values:\n", + " N = int(T / dt) + 1 # number of time-steps\n", + " t = numpy.linspace(0.0, T, num=N) # time grid\n", + " # Set the initial conditions.\n", + " u = numpy.array([z0, b0])\n", + " z = numpy.empty_like(t)\n", + " z[0] = z0\n", + " # Temporal integration using Euler's method.\n", + " for n in range(1, N):\n", + " rhs = numpy.array([u[1], g * (1 - u[0] / zt)])\n", + " u = u + dt * rhs\n", + " z[n] = u[0] # store the elevation at time-step n+1\n", + " z_values.append(z) # store the elevation over the time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculate the error" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now have numerical solutions for each $\\Delta t$ in the array `z_values`. To calculate the error corresponding to each $\\Delta t$, we can write a function! " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def l1_error(z, z_exact, dt):\n", + " \"\"\"\n", + " Computes and returns the error\n", + " (between the numerical and exact solutions)\n", + " in the L1 norm.\n", + " \n", + " Parameters\n", + " ----------\n", + " z : numpy.ndarray\n", + " The numerical solution as an array of floats.\n", + " z_exact : numpy.ndarray\n", + " The analytical solution as an array of floats.\n", + " dt : float\n", + " The time-step size.\n", + " \n", + " Returns\n", + " -------\n", + " error: float\n", + " L1-norm of the error with respect to the exact solution.\n", + " \"\"\"\n", + " error = dt * numpy.sum(numpy.abs(z - z_exact))\n", + " return error" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**: in the first line of the function, we perform an 'array operation': \n", + "\n", + "`z - z_exact`\n", + "\n", + "We are *not* subtracting one value from another. Instead, we are taking the difference between elements at each corresponding index in both arrays. Here is a quick example:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([3, 2, 1])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = numpy.array([1, 2, 3])\n", + "b = numpy.array([4, 4, 4])\n", + "\n", + "b - a" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we iterate through each $\\Delta t$ value and calculate the corresponding error.\n", + "In the following code cell, we use the built-in function [`zip`](https://docs.python.org/3/library/functions.html#zip) to iterate over the two lists `z_values` and `dt_values`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Create an empty list to store the errors on each time grid.\n", + "error_values = []\n", + "\n", + "for z, dt in zip(z_values, dt_values):\n", + " N = int(T / dt) + 1 # number of time-steps\n", + " t = numpy.linspace(0.0, T, num=N) # time grid\n", + " # Compute the exact solution.\n", + " z_exact = (b0 * (zt / g)**0.5 * numpy.sin((g / zt)**0.5 * t) +\n", + " (z0 - zt) * numpy.cos((g / zt)**0.5 * t) + zt)\n", + " # Calculate the L1-norm of the error for the present time grid.\n", + " error_values.append(l1_error(z, z_exact, dt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remember, *if* the method is convergent then the error should get smaller as $\\Delta t$ gets smaller. To visualize this, let's plot $\\Delta t$ vs. error. If you use `pyplot.plot` you won't get a very useful result. Instead, use `pyplot.loglog` to create the same plot with a log-log scale. This is what we do almost always to assess the errors of a numerical scheme graphically." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the error versus the time-step size.\n", + "pyplot.figure(figsize=(6.0, 6.0))\n", + "pyplot.title('L1-norm error vs. time-step size') # set the title\n", + "pyplot.xlabel('$\\Delta t$') # set the x-axis label\n", + "pyplot.ylabel('Error') # set the y-axis label\n", + "pyplot.grid()\n", + "pyplot.loglog(dt_values, error_values,\n", + " color='C0', linestyle='--', marker='o') # log-log plot\n", + "pyplot.axis('equal'); # make axes scale equally" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is the kind of result we like to see! As $\\Delta t$ shrinks (towards the left), the error gets smaller and smaller, like it should." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Challenge!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We calculated the solution for several different time-step sizes using two nested `for` loops.\n", + "That worked, but whenever possible, we like to re-use code (and not just copy and paste it!).\n", + "\n", + "Create a function that implements Euler's method and re-write the code cell that computes the solution for different time-step sizes using your function." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb b/2-finite-difference-method/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb new file mode 100644 index 0000000..16d86bc --- /dev/null +++ b/2-finite-difference-method/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb @@ -0,0 +1,946 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth, I. Hawke. Partly based on content by David Ketcheson, also under CC-BY." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Full phugoid model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is the third Jupyter Notebook of the series on the _phugoid model of glider flight_, our first learning module of the course [\"Practical Numerical Methods with Python\"](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about). In the [first notebook](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_01_Phugoid_Theory.ipynb), we described the physics of the trajectories known as phugoids obtained from an exchange of potential and kinetic energy in an idealized motion with no drag. We gave you a neat little code to play with and plot various phugoid curves.\n", + "\n", + "In the second notebook, we looked at the equation representing small perturbations on the straight-line phugoid, resulting in simple harmonic motion. This is a second-order ordinary differential equation, and we solved it numerically using **Euler's method**: the simplest numerical method of all. We learned about convergence and calculated the error of the numerical solution, comparing with an analytical solution. That is a good foundation!\n", + "\n", + "Now, let's go back to the dynamical model, and take away the idealization of no-drag. Let's remind ourselves of the forces affecting an aircraft, considering now that it may be accelerating, with an instantaneous upward trajectory. We use the designation $\\theta$ for the angle, and consider it positive upwards." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Image](./figures/glider_forces-lesson3.png)\n", + "#### Figure 1. Forces with a positive trajectory angle." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In Figure 1, $L$ is the lift, $W$ is the weight, $D$ is the drag, and $\\theta$ the positive angle of the trajectory, instantaneously. \n", + "\n", + "In [Lesson 1](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_01_Phugoid_Theory.ipynb), we wrote the force balance in the directions perpendicular and parallel to the trajectory for a glider in _equilibrium_. What if the forces are _not_ in balance? Well, there will be acceleration terms in the equations of motion, and we would have in that case:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "m \\frac{dv}{dt} & = - W \\sin\\theta - D \\\\\n", + "m v \\, \\frac{d\\theta}{dt} & = - W \\cos\\theta + L\n", + "\\end{align}\n", + "$$\n", + "\n", + "We can use a few little tricks to make these equations more pleasing. First, use primes to denote the time derivatives and divide through by the weight:\n", + "\n", + "$$\n", + "\\begin{align}\n", + " \\frac{v'}{g} & = - \\sin\\theta - D/W \\\\\n", + "\\frac{v}{g} \\, \\theta' & = - \\cos\\theta + L/W\n", + "\\end{align}\n", + "$$\n", + "\n", + "Recall, from our first lesson, that the ratio of lift to weight is known from the trim conditions—$L/W=v^2/v_t^2$— and also from the definitions of lift and drag, \n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "L &=& C_L S \\times \\frac{1}{2} \\rho v^2 \\\\\n", + "D &=& C_D S \\times \\frac{1}{2} \\rho v^2\n", + "\\end{eqnarray}\n", + "$$\n", + "\n", + "we see that $L/D=C_L/C_D$. The system of equations can be re-written:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "v' & = - g\\, \\sin\\theta - \\frac{C_D}{C_L} \\frac{g}{v_t^2} v^2 \\\\\n", + "\\theta' & = - \\frac{g}{v}\\,\\cos\\theta + \\frac{g}{v_t^2}\\, v\n", + "\\end{align}\n", + "$$\n", + "\n", + "It is very interesting that the first equation has the factor $C_D/C_L$, which is the inverse of a measure of the aerodynamic efficiency of the aircraft. It turns out, this is the term that contributes damping to the phugoid model: if drag is zero, there is no damping. Drag is never zero in real life, but as engineers design more aerodynamically efficient aircraft, they make the phugoid mode more weakly damped. At altitude, this is nothing but a slight bother, but vertical oscillations are unsafe during final approach to land, so this is something to watch out for!\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The initial value problem" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we want to visualize the flight trajectories predicted by this model, we are going to need to integrate the spatial coordinates, which depend on both the forward velocity (tangential to the trajectory) and the trajectory angle. The position of the glider on a vertical plane will be designated by coordinates $(x, y)$ with respect to an inertial frame of reference, and are obtained from:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "x'(t) & = v \\cos(\\theta) \\\\\n", + "y'(t) & = v \\sin(\\theta)\n", + "\\end{align}\n", + "$$\n", + "\n", + "Augmenting our original two differential equations by the two equations above, we have a system of four first-order differential equations to solve. We will use a time-stepping approach, like in the previous lesson. To do so, we do need *initial values* for every unknown:\n", + "\n", + "$$\n", + "v(0) = v_0 \\quad \\text{and} \\quad \\theta(0) = \\theta_0 \\\\\n", + "x(0) = x_0 \\quad \\text{and} \\quad y(0) = y_0\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solve with Euler's method" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We know how to apply Euler's method from the previous lesson. We replace each of the time derivatives by an approximation of the form:\n", + "\n", + "$$\n", + "v'(t) \\approx \\frac{v^{n+1} - v^n}{\\Delta t}\n", + "$$\n", + "\n", + "where we are now using a superscript $n$ to indicate the $n$-th value in the time iterations. The first differential equation, for example, gives:\n", + "\n", + "$$\n", + "\\frac{v^{n+1} - v^n}{\\Delta t} = - g\\, \\sin\\theta^n - \\frac{C_D}{C_L} \\frac{g}{v_t^2} (v^n)^2\n", + "$$\n", + "\n", + "Alright, we know where this is going. At each time iteration $t^n$, we want to evaluate all the known data of our system to obtain the state at $t^{n+1}$—the next time step. We say that we are _stepping in time_ or _time marching_.\n", + "\n", + "The full system of equations discretized with Euler's method is:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "v^{n+1} & = v^n + \\Delta t \\left(- g\\, \\sin\\theta^n - \\frac{C_D}{C_L} \\frac{g}{v_t^2} (v^n)^2 \\right) \\\\\n", + "\\theta^{n+1} & = \\theta^n + \\Delta t \\left(- \\frac{g}{v^n}\\,\\cos\\theta^n + \\frac{g}{v_t^2}\\, v^n \\right) \\\\\n", + "x^{n+1} & = x^n + \\Delta t \\, v^n \\cos\\theta^n \\\\\n", + "y^{n+1} & = y^n + \\Delta t \\, v^n \\sin\\theta^n.\n", + "\\end{align}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we've learned before, the system of differential equations can also be written as a vector equation:\n", + "\n", + "$$\n", + "u'(t) = f(u)\n", + "$$\n", + "\n", + "where\n", + "\n", + "$$\n", + "\\begin{align}\n", + "u & = \\begin{pmatrix} v \\\\ \\theta \\\\ x \\\\ y \\end{pmatrix} & f(u) & = \\begin{pmatrix} - g\\, \\sin\\theta - \\frac{C_D}{C_L} \\frac{g}{v_t^2} v^2 \\\\ - \\frac{g}{v}\\,\\cos\\theta + \\frac{g}{v_t^2}\\, v \\\\ v\\cos\\theta \\\\ v\\sin\\theta \\end{pmatrix}\n", + "\\end{align}\n", + "$$\n", + "\n", + "It's a bit tricky to code the solution using a NumPy array holding all your independent variables. But if you do, a function for the Euler step can be written that takes any number of simultaneous equations. It simply steps in time using the same line of code:\n", + "\n", + "```Python\n", + "def euler_step(u, f, dt):\n", + " return u + dt * f(u)\n", + "```\n", + "\n", + "This function can take a NumPy array `u` with any number of components. All we need to do is create an appropriate function `f(u)` describing our system of differential equations. Notice how we are passing a _function_ as part of the arguments list to `euler_step()`. Neat!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### And solve!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As always, we start by loading the modules and libraries that we need for this problem. We'll need a few transcendental functions, including the $\\log$ for a convergence study later on. And remember: the line `%matplotlib inline` is a magic function that tells Matplotlib to give us the plots in the notebook (the default behavior of Matplotlib is to open a pop-up window)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition, we modify some entries of the `rcParams` dictionary of `pyplot` to define notebook-wide plotting parameters: font family and font size.\n", + "Here we go!" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we need to set things up to start our numerical solution: the parameter \n", + "values and the _initial values_. You know what the acceleration of gravity is: 9.81 m/s$^2$, but what are good values for $C_D/C_L$, the inverse of the aerodynamic efficiency? Some possible values are given on a table in the Wikipedia entry for [lift-to-drag ratio](http://en.wikipedia.org/wiki/Lift-to-drag_ratio): a modern sailplane can have $L/D$ of 40 to 60, depending on span (and, in case you're interested, a flying squirrel has $L/D$ close to 2).\n", + "\n", + "For the _trim velocity_, the speed range for typical sailplanes is between 65 and 280 km/hr, according to Wikipedia (it must be right!). Let's convert that to meters per second: 18 to 78 m/s. We'll pick a value somewhere in the middle of this range.\n", + "\n", + "Here's a possible set of parameters for the simulation, but be sure to come back and change some of these, and see what happens!" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "g = 9.81 # gravitational acceleration (m.s^{-2})\n", + "vt = 30.0 # trim velocity (m.s)\n", + "CD = 1.0 / 40 # drag coefficient\n", + "CL = 1.0 # lift coefficient\n", + "\n", + "# Set initial conditions.\n", + "v0 = vt # start at the trim velocity\n", + "theta0 = 0.0 # trajectory angle\n", + "x0 = 0.0 # horizontal position\n", + "y0 = 1000.0 # vertical position (altitude)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll define a function `rhs_phugoid()` to match the right-hand side of Equation (15), the full differential system in vector form. This function assumes that we have available the parameters defined above. If you re-execute the cell above with different parameter values, you can just run the solution without re-executing the function definition." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def rhs_phugoid(u, CL, CD, g, vt):\n", + " \"\"\"\n", + " Returns the right-hand side of the phugoid system of equations.\n", + " \n", + " Parameters\n", + " ----------\n", + " u : list or numpy.ndarray\n", + " Solution at the previous time step\n", + " as a list or 1D array of four floats.\n", + " CL : float\n", + " Lift coefficient.\n", + " CD : float\n", + " Drag coefficient.\n", + " g : float\n", + " Gravitational acceleration.\n", + " vt : float\n", + " Trim velocity.\n", + " \n", + " Returns\n", + " -------\n", + " rhs : numpy.ndarray\n", + " The right-hand side of the system\n", + " as a 1D array of four floats.\n", + " \"\"\"\n", + " v, theta, x, y = u\n", + " rhs = numpy.array([-g * math.sin(theta) - CD / CL * g / vt**2 * v**2,\n", + " -g * math.cos(theta) / v + g / vt**2 * v,\n", + " v * math.cos(theta),\n", + " v * math.sin(theta)])\n", + " return rhs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compare the code defining function `rhs_phugoid()` with the differential equations, and convince yourself that it's right!\n", + "\n", + "$$\n", + "\\begin{align}\n", + "u & = \\begin{pmatrix} v \\\\ \\theta \\\\ x \\\\ y \\end{pmatrix} & f(u) & = \\begin{pmatrix} - g\\, \\sin\\theta - \\frac{C_D}{C_L} \\frac{g}{v_t^2} v^2 \\\\ - \\frac{g}{v}\\,\\cos\\theta + \\frac{g}{v_t^2}\\, v \\\\ v\\cos\\theta \\\\ v\\sin\\theta \\end{pmatrix} \\nonumber\n", + "\\end{align}\n", + "$$\n", + "\n", + "Now, Euler's method is implemented in a simple function `euler_step()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def euler_step(u, f, dt, *args):\n", + " \"\"\"\n", + " Returns the solution at the next time step using Euler's method.\n", + " \n", + " Parameters\n", + " ----------\n", + " u : numpy.ndarray\n", + " Solution at the previous time step\n", + " as a 1D array of floats.\n", + " f : function\n", + " Function to compute the right-hand side of the system.\n", + " dt : float\n", + " Time-step size.\n", + " args : tuple, optional\n", + " Positional arguments to pass to the function f.\n", + " \n", + " Returns\n", + " -------\n", + " u_new : numpy.ndarray\n", + " The solution at the next time step\n", + " as a 1D array of floats.\n", + " \"\"\"\n", + " u_new = u + dt * f(u, *args)\n", + " return u_new" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**—We use an optional input to the function `euler_step()`, named `*args`. It passes to the function `f()` an arbitrary number of arguments. Doing so, `euler_step()` can take any function `f()`, regardless of the number of arguments this function needs. Sweet! (Read the Python documentation about [Arbitrary Argument Lists](https://docs.python.org/3/tutorial/controlflow.html#arbitrary-argument-lists) for more explanations.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After defining a final time for the solution, and the time step $\\Delta t$, we can construct the grid in time using the NumPy function [`linspace()`](http://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html). Make sure you study the decisions we made here to build the time grid: why do we add 1 to the definition of `N`, for example?\n", + "\n", + "Look at the code below, and make sure you understand the following aspects of it.\n", + "\n", + "* The NumPy array `u` contains the solution at every time-step, consisting of the velocity, angle and location of the glider. \n", + "* The first element of the array `u` is set to contain the initial conditions. \n", + "* In the `for`-loop, the function `euler_step()` is called to get the solution at time-step $n+1$. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "T = 100.0 # length of the time interval\n", + "dt = 0.1 # time-step size\n", + "N = int(T / dt) + 1 # number of time steps\n", + "\n", + "# Create array to store the solution at each time step.\n", + "u = numpy.empty((N, 4))\n", + "# Set the initial conditions.\n", + "u[0] = numpy.array([v0, theta0, x0, y0])\n", + "\n", + "# Time integration with Euler's method.\n", + "for n in range(N - 1):\n", + " u[n + 1] = euler_step(u[n], rhs_phugoid, dt, CL, CD, g, vt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot the trajectory" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to plot the path of the glider, we need the location (`x`, `y`) with respect to time. That information is already contained in our NumPy array containing the solution; we just need to pluck it out. \n", + "\n", + "Make sure you understand the indices to `u`, below, and the use of the colon notation. If any of it is confusing, read the Python documentation on [Indexing](https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Get the glider's position over the time.\n", + "x = u[:, 2]\n", + "y = u[:, 3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Time to plot the path of the glider and get the distance travelled!" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the path of the glider.\n", + "pyplot.figure(figsize=(9.0, 4.0))\n", + "pyplot.title('Path of the glider (flight time = {})'.format(T))\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('y')\n", + "pyplot.grid()\n", + "pyplot.plot(x, y, color='C0', linestyle='-', linewidth=2);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Grid convergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's study the convergence of Euler's method for the phugoid model. In the previous lesson, when we studied the straight-line phugoid under a small perturbation, we looked at convergence by comparing the numerical solution with the exact solution. Unfortunately, most problems don't have an exact solution (that's why we compute in the first place!). But here's a neat thing: we can use numerical solutions computed on different grids to study the convergence of the method, even without an analytical solution.\n", + "\n", + "We need to be careful, though, and make sure that the fine-grid solution is resolving all of the features in the mathematical model. How can we know this? We'll have a look at that in a bit. Let's see how this works first.\n", + "\n", + "You need a sequence of numerical solutions of the same problem, each with a different number of time grid points.\n", + "\n", + "Let's create a list of floats called `dt_values` that contains the time-step size of each grid to be solved on. For each element of `dt_values`, we will compute the solution `u` of the glider model using Euler's method and add it to the list `u_values` (initially empty).\n", + "If we want to use five different values of $\\Delta t$, we'll have five elements in the list `u_values`, each element being a Numpy array. We'll have a list of Numpy arrays! How meta is that?\n", + "\n", + "Read the code below carefully, and remember: you can get a help panel on any function by entering a question mark followed by the function name. For example, add a new code cell below and type: `?numpy.empty`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the list of time-step sizes.\n", + "dt_values = [0.1, 0.05, 0.01, 0.005, 0.001]\n", + "\n", + "# Create an empty list that will contain the solution of each grid.\n", + "u_values = []\n", + "\n", + "for dt in dt_values:\n", + " N = int(T / dt) + 1 # number of time-steps\n", + " # Create array to store the solution at each time step.\n", + " u = numpy.empty((N, 4))\n", + " # Set the initial conditions.\n", + " u[0] = numpy.array([v0, theta0, x0, y0])\n", + " # Temporal integration using Euler's method.\n", + " for n in range(N - 1):\n", + " u[n + 1] = euler_step(u[n], rhs_phugoid, dt, CL, CD, g, vt)\n", + " # Store the solution for the present time-step size\n", + " u_values.append(u)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In [Lesson 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_02_Phugoid_Oscillation.ipynb), we compared our numerical result to an analytical solution, but now we will instead compare numerical results from different grids. \n", + "\n", + "For each solution, we'll compute the difference relative to the finest grid. You will be tempted to call this an _\"error\"_, but be careful: the solution at the finest grid is _not the exact_ solution, it is just a reference value that we can use to estimate grid convergence.\n", + "\n", + "To calculate the difference between one solution `u_current` and the solution at the finest grid, `u_finest`, we'll use the $L_1$-norm, but any norm will do.\n", + "\n", + "There is a small problem with this, though. The coarsest grid, where $\\Delta t = 0.1$, has 1001 grid points, while the finest grid, with $\\Delta t = 0.001$ has 100001 grid points. How do we know which grid points correspond to the same location in two numerical solutions, in order to compare them? \n", + "\n", + "If we had time grids of 10 and 100 steps, respectively, this would be relatively simple to calculate. Each element in our 10-step grid would span ten elements in our 100-step grid. \n", + "\n", + "Calculating the _ratio_ of the two grid sizes will tell us how many elements in our fine-grid will span over one element in our coarser grid.\n", + "\n", + "Recall that we can _slice_ a NumPy array and grab a subset of values from it. The syntax for that is\n", + "\n", + "```Python\n", + "my_array[3:8]\n", + "```\n", + "\n", + "An additional slicing trick that we can take advantage of is the \"slice step size.\" We add an additional `:` to the slice range and then specify how many steps to take between elements. For example, this code\n", + "\n", + "```Python\n", + "my_array[3:8:2]\n", + "```\n", + "\n", + "will return the values of `my_array[3]`, `my_array[5]` and `my_array[7]`\n", + "\n", + "With that, we can write a function to obtain the differences between coarser and finest grids. Here we go ..." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def l1_diff(u_coarse, u_fine, dt):\n", + " \"\"\"\n", + " Returns the difference in the L1-norm between the solution on\n", + " a coarse grid and the solution on a fine grid.\n", + " \n", + " Parameters\n", + " ----------\n", + " u_coarse : numpy.ndarray\n", + " Solution on the coarse grid as an array of floats.\n", + " u_fine : numpy.ndarray\n", + " Solution on the fine grid as an array of floats.\n", + " dt : float\n", + " Time-step size.\n", + " \n", + " Returns\n", + " -------\n", + " diff : float\n", + " The difference between the two solutions in the L1-norm\n", + " scaled by the time-step size.\n", + " \"\"\"\n", + " N_coarse = len(u_coarse)\n", + " N_fine = len(u_fine)\n", + " ratio = math.ceil(N_fine / N_coarse)\n", + " diff = dt * numpy.sum(numpy.abs(u_coarse - u_fine[::ratio]))\n", + " return diff" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that the function has been defined, let's compute the grid differences for each solution, relative to the fine-grid solution. Call the function `l1_diff()` with two solutions, one of which is always the one at the finest grid. Here's a neat Python trick: you can use negative indexing in Python! If you have an array called `my_array` you access the _first_ element with\n", + "\n", + "`my_array[0]`\n", + "\n", + "But you can also access the _last_ element with \n", + "\n", + "`my_array[-1]`\n", + "\n", + "and the next to last element with\n", + "\n", + "`my_array[-2]`\n", + "\n", + "and so on. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Create an empty list to store the difference in the solution\n", + "# between two consecutive grids.\n", + "diff_values = []\n", + "\n", + "for i, dt in enumerate(dt_values[:-1]):\n", + " diff = l1_diff(u_values[i][:, 2], u_values[-1][:, 2], dt)\n", + " diff_values.append(diff)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Time to create a plot of the results! We'll create a *log-log* plot with the Matplotlib function [`loglog()`](https://matplotlib.org/api/pyplot_api.html?highlight=loglog#matplotlib.pyplot.loglog). Remember to skip the difference of the finest-grid solution with itself, which is zero." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the difference versus the time-step size.\n", + "pyplot.figure(figsize=(6.0, 6.0))\n", + "pyplot.title('L1-norm difference vs. time-step size') # set the title\n", + "pyplot.xlabel('$\\Delta t$') # set the x-axis label\n", + "pyplot.ylabel('Difference') # set the y-axis label\n", + "pyplot.grid()\n", + "pyplot.loglog(dt_values[:-1], diff_values,\n", + " color='C0', linestyle='--', marker='o') # log-log plot\n", + "pyplot.axis('equal'); # make axes scale equally" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Order of convergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The order of convergence is the rate at which the numerical solution approaches the exact one as the mesh is refined. Considering that we're not comparing with an exact solution, we use 3 grid resolutions that are refined at a constant ratio $r$ to find the *observed order of convergence* ($p$), which is given by:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p = \\frac{\\log \\left(\\frac{f_3-f_2}{f_2-f_1} \\right) }{\\log(r)}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $f_1$ is the finest mesh solution, and $f_3$ the coarsest. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Observed order of convergence: p = 1.014\n" + ] + } + ], + "source": [ + "r = 2 # refinement ratio for the time-step size\n", + "h = 0.001 # base grid size\n", + "\n", + "dt_values2 = [h, r * h, r**2 * h]\n", + "u_values2 = []\n", + "\n", + "for dt in dt_values2:\n", + " N = int(T / dt) + 1 # number of time steps\n", + " # Create array to store the solution at each time step.\n", + " u = numpy.empty((N, 4))\n", + " # Set initial conditions.\n", + " u[0] = numpy.array([v0, theta0, x0, y0])\n", + " # Time integration using Euler's method.\n", + " for n in range(N - 1):\n", + " u[n + 1] = euler_step(u[n], rhs_phugoid, dt, CL, CD, g, vt)\n", + " # Store the solution.\n", + " u_values2.append(u)\n", + "\n", + "# Calculate f2 - f1.\n", + "f2_f1 = l1_diff(u_values2[1][:, 2], u_values2[0][:, 2], dt_values2[1])\n", + "# Calculate f3 - f2.\n", + "f3_f2 = l1_diff(u_values2[2][:, 2], u_values2[1][:, 2], dt_values2[2])\n", + "# Calculate the observed order of convergence.\n", + "p = math.log(f3_f2 / f2_f1) / math.log(r)\n", + "print('Observed order of convergence: p = {:.3f}'.format(p))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "See how the observed order of convergence is close to 1? This means that the rate at which the grid differences decrease match the mesh-refinement ratio. We say that Euler's method is of *first order*, and this result is a consequence of that." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Paper airplane challenge" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Suppose you wanted to participate in a paper-airplane competition, and you want to use what you know about the phugoid model to improve your chances. For a given value of $L/D$ that you can obtain in your design, you want to know what is the best initial velocity and launch angle to fly the longest distance from a given height.\n", + "\n", + "Using the phugoid model, write a new code to analyze the flight of a paper airplane, with the following conditions:\n", + "\n", + "* Assume $L/D$ of 5.0 (a value close to measurements in Feng et al. 2009)\n", + "* For the trim velocity, let's take an average value of 4.9 m/s.\n", + "* Find a combination of launch angle and velocity that gives the best distance.\n", + "* Think about how you will know when the flight needs to stop ... this will influence how you organize the code.\n", + "* How can you check if your answer is realistic?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Feng, N. B. et al. _\"On the aerodynamics of paper airplanes\"_, AIAA paper 2009-3958, 27th AIAA Applied Aerodynamics Conference, San Antonio, TX. [PDF](http://arc.aiaa.org/doi/abs/10.2514/6.2009-3958)\n", + "\n", + "* Simanca, S. R. and Sutherland, S. _\"Mathematical problem-solving with computers,\"_ 2002 course notes, Stony Brook University, chapter 3: [The Art of Phugoid](https://www.math.sunysb.edu/~scott/Book331/Art_Phugoid.html). (Note that there is an error in the figure: sine and cosine are switched.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/01_phugoid/01_04_Second_Order_Methods.ipynb b/2-finite-difference-method/lessons/01_phugoid/01_04_Second_Order_Methods.ipynb new file mode 100644 index 0000000..5480eb7 --- /dev/null +++ b/2-finite-difference-method/lessons/01_phugoid/01_04_Second_Order_Methods.ipynb @@ -0,0 +1,1194 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth, C.D. Cooper. Partly based on content by David Ketcheson, also under CC-BY." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Phugoid model: bonus!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_The phugoid model of glider flight_ has been such a fun problem to showcase the power of numerical solution of differential equations, we thought you'd enjoy a bonus notebook. The previous lessons were:\n", + "\n", + "* [Phugoid motion](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_01_Phugoid_Theory.ipynb) —Lays the groundwork for our fun problem, with some context, a little history and a description of the physics of phugoids: curves representing the trajectory of a glider exchanging potential and kinetic energy, with no drag.\n", + "* [Phugoid oscillation](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_02_Phugoid_Oscillation.ipynb) —Develops the simple harmonic motion of an aircraft experiencing a small perturbation from the horizontal trajectory: our opportunity to introduce Euler's method, and study its convergence via an exact solution.\n", + "* [Full phugoid motion](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb) —The full model takes into account the force of drag and results in a system of two nonlinear equations. We obtain the trajectories using Euler's method in vectorized form, introduce grid-convergence analysis and finish with the paper-airplane challenge!\n", + "\n", + "That is a fantastic foundation for numerical methods. It's a good time to complement it with some theory: the first screencast of the course uses Taylor series to show that _Euler's method is a first-order method_, and we also show you graphical interpretations. Many problems require a more accurate method, though: second order or higher. Among the most popular higher-order methods that we can mention are the _Runge-Kutta methods_, developed around 1900: more than 100 years after Euler published his book containing the method now named after him!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Euler's method is a first-order method" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this screencast, we use a Taylor series expansion to analyze Euler's method and show that it incurs a truncation error of first order. We also use a graphical interpretation to motivate the _modified_ Euler method, which achieves second order." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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\n", + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import YouTubeVideo\n", + "YouTubeVideo('6i6qhqDCViA')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Second-order methods" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The notebook on phugoid oscillation (lesson 2) included a study of the accuracy obtained with Euler's method, using the exact solution for the simple harmonic motion. We made a _convergence plot_ and saw that as $\\Delta t$ gets smaller, the error also gets smaller. \n", + "\n", + "We could have drawn a line with a slope equal to 1 on that log-log plot, and you would have seen that it was parallel to the convergence line. A slope equal to 1 on a log-log convergence plot is an indication that we have a first-order method: the error scales as ${\\mathcal O}(\\Delta t)$. \n", + "\n", + "In lesson 3, using the full phugoid model (which is nonlinear and does not have an exact solution), we did a _grid-convergence study_ with three different grids, and obtained the _observed_ order of convergence—it was very close to 1, indicating a slope of 1 on a log-log plot.\n", + "\n", + "Another way to look at an ${\\mathcal O}(\\Delta t)$ method is to say that the error scales _linearly_ with the step size, or that they are proportional:\n", + "\n", + "$$\n", + "e \\propto \\Delta t\n", + "$$\n", + "\n", + "where $e$ stands for the error. To get more accuracy, we could use a _second-order_ method, in which the error is ${\\mathcal O}(\\Delta t^2)$. In general, we say that a method is of order $p$ when the error is proportional to $(\\Delta t)^p$.\n", + "\n", + "In the screencast titled \"Euler's method is a first-order method,\" we used a graphical interpretation to get an idea for improving it: by estimating an intermediate point, like the **midpoint**, we can get a better approximation of the area under the curve of $u^\\prime$. The scheme has two steps and is written as:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "u_{n+1/2} & = u_n + \\frac{\\Delta t}{2} f(u_n) \\\\\n", + "u_{n+1} & = u_n + \\Delta t \\,\\, f(u_{n+1/2})\n", + "\\end{align}\n", + "$$\n", + "\n", + "This method is known as the *explicit midpoint method* or the *modified Euler method*, and it is a second-order method. Notice that we had to apply the right-hand side, $~f(u)$, twice. This idea can be extended: we could imagine estimating additional points between $u_{n}$ and $u_{n+1}$ and evaluating $~f(u)$ at the intermediate points to get higher accuracy—that's the idea behind Runge-Kutta methods." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Runge-Kutta methods" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the modified Euler method, we improve the accuracy over Euler's method by evaluating the right-hand side of the differential equation at an intermediate point: the midpoint. The same idea can be applied again, and the function $f(u)$ can be evaluated at more intermediate points, improving the accuracy even more. This is the basis of the famous *Runge-Kutta (RK) methods*, going back to Carl Runge and Martin Kutta. The modified Euler method corresponds to _second-order_ Runge-Kutta.\n", + "\n", + "Here's a bit of historical coincidence that will blow your mind: Carl Runge's daughter Iris—an accomplished applied mathematician in her own right—worked assiduously over the summer of 1909 to translate Lanchester's _\"Aerodonetics.\"_ She also reproduced his graphical method to draw the phugoid curves (Tobies, 2012)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Phugoid model with 2nd-order RK" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's compute the motion of a glider under the full phugoid model using the second-order Runge-Kutta method. We'll build on the _paper airplane challenge_ of lesson 3 now, and look for the horizontal distance that the plane travels until the moment it touches the ground. \n", + "\n", + "As usual, let's start by importing the libraries and modules that we need, and setting up the model parameters. We also set some default plotting formats by modifying entries of the `rcParams` dictionary." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the paper-airplane challenge of lesson 3, we suggested an $L/D=5.0$ as a realistic value for paper airplanes, according to experiments, and a trim velocity of 4.9 m/s. Let's start with those values, but you could experiment changing these a bit. _What do you think will happen if you make $L/D$ higher?_" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "g = 9.81 # gravitational acceleration (m.s^{-2})\n", + "vt = 4.9 # trim velocity (m.s)\n", + "CD = 1.0 / 5.0 # drag coefficient\n", + "CL = 1.0 # lift coefficient\n", + "\n", + "# Set initial conditions.\n", + "v0 = 6.5 # start at the trim velocity\n", + "theta0 = -0.1 # trajectory angle\n", + "x0 = 0.0 # horizontal position\n", + "y0 = 2.0 # vertical position (altitude)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Among the initial parameters that we suggest for your first experiment, we are starting with a velocity a little higher than the trim velocity, launch the paper airplane with a negative initial angle, and take the initial height to be 2 meters—all sound like reasonable choices.\n", + "\n", + "Now, we can define a few functions to carry out the computation:\n", + "* The right-hand side of the phugoid model from [Lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb),\n", + "* One step of the Euler's method that we learned in [Lesson 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_02_Phugoid_Oscillation.ipynb), and\n", + "* Differences with respect to a fine grid, as in [Lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def rhs_phugoid(u, CL, CD, g, vt):\n", + " \"\"\"\n", + " Returns the right-hand side of the phugoid system of equations.\n", + " \n", + " Parameters\n", + " ----------\n", + " u : list or numpy.ndarray\n", + " Solution at the previous time step\n", + " as a list or 1D array of four floats.\n", + " CL : float\n", + " Lift coefficient.\n", + " CD : float\n", + " Drag coefficient.\n", + " g : float\n", + " Gravitational acceleration.\n", + " vt : float\n", + " Trim velocity.\n", + " \n", + " Returns\n", + " -------\n", + " rhs : numpy.ndarray\n", + " The right-hand side of the system\n", + " as a 1D array of four floats.\n", + " \"\"\"\n", + " v, theta, x, y = u\n", + " rhs = numpy.array([-g * math.sin(theta) - CD / CL * g / vt**2 * v**2,\n", + " -g * math.cos(theta) / v + g / vt**2 * v,\n", + " v * math.cos(theta),\n", + " v * math.sin(theta)])\n", + " return rhs\n", + "\n", + "\n", + "def euler_step(u, f, dt, *args):\n", + " \"\"\"\n", + " Returns the solution at the next time step using Euler's method.\n", + " \n", + " Parameters\n", + " ----------\n", + " u : numpy.ndarray\n", + " Solution at the previous time step\n", + " as a 1D array of floats.\n", + " f : function\n", + " Function to compute the right-hand side of the system.\n", + " dt : float\n", + " Time-step size.\n", + " args : tuple, optional\n", + " Positional arguments to pass to the function f.\n", + " \n", + " Returns\n", + " -------\n", + " u_new : numpy.ndarray\n", + " The solution at the next time step\n", + " as a 1D array of floats.\n", + " \"\"\"\n", + " u_new = u + dt * f(u, *args)\n", + " return u_new\n", + "\n", + "\n", + "def l1_diff(u_coarse, u_fine, dt):\n", + " \"\"\"\n", + " Returns the difference in the L1-norm between the solution on\n", + " a coarse grid and the solution on a fine grid.\n", + " \n", + " Parameters\n", + " ----------\n", + " u_coarse : numpy.ndarray\n", + " Solution on the coarse grid as a 1D array of floats.\n", + " u_fine : numpy.ndarray\n", + " Solution on the fine grid as a 1D array of floats.\n", + " dt : float\n", + " Time-step size.\n", + " \n", + " Returns\n", + " -------\n", + " diff : float\n", + " The difference between the two solution in the L1-norm\n", + " scaled by the time-step size.\n", + " \"\"\"\n", + " N_coarse = u_coarse.shape[0]\n", + " N_fine = u_fine.shape[0]\n", + " ratio = math.ceil(N_fine / N_coarse)\n", + " diff = dt * numpy.sum(numpy.abs(u_coarse - u_fine[::ratio]))\n", + " return diff" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we also need to define the function `rk2_step()` that computes the next time step using the *modified Euler* method of equations $(1)$ and $(2)$, above, otherwise known as 2nd-order Runge-Kutta or RK2. This function will be called over and over again within the time loop." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def rk2_step(u, f, dt, *args):\n", + " \"\"\"\n", + " Returns the solution at the next time step using 2nd-order\n", + " Runge-Kutta method.\n", + " \n", + " Parameters\n", + " ----------\n", + " u : numpy.ndarray\n", + " Solution at the previous time step\n", + " as a 1D array of floats.\n", + " f : function\n", + " Function to compute the right-hand side of the system.\n", + " dt : float\n", + " Time-step size.\n", + " args : tuple, optional\n", + " Positional arguments to pass to the function f.\n", + " \n", + " Returns\n", + " -------\n", + " u_new : numpy.ndarray\n", + " The solution at the next time step\n", + " as a 1D array of floats.\n", + " \"\"\"\n", + " u_star = u + 0.5 * dt * f(u, *args)\n", + " u_new = u + dt * f(u_star, *args)\n", + " return u_new" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Like in [Lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb), we first need to set up the time discretization, then initialize arrays to save the solution and we are set to go! The only difference this time is that we are using _both_ Euler's method and 2nd-order Runge-Kutta to get a solution, to compare the two. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "T = 15.0 # length of the time interval\n", + "dt = 0.01 # time-step size\n", + "N = int(T / dt) + 1 # number of time steps\n", + "\n", + "# Create arrays to store the solution at each time step.\n", + "u_euler = numpy.empty((N, 4))\n", + "u_rk2 = numpy.empty((N, 4))\n", + "\n", + "# Set the initial conditions.\n", + "u_euler[0] = numpy.array([v0, theta0, x0, y0])\n", + "u_rk2[0] = numpy.array([v0, theta0, x0, y0])\n", + "\n", + "# Time integration with both method.\n", + "for n in range(N - 1):\n", + " u_euler[n + 1] = euler_step(u_euler[n], rhs_phugoid, dt,\n", + " CL, CD, g, vt)\n", + " u_rk2[n + 1] = rk2_step(u_rk2[n], rhs_phugoid, dt,\n", + " CL, CD, g, vt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can get the position of the glider in time, according to both Euler's method and the 2nd-order Runge-Kutta method, by extracting the appropriate portions of the solution arrays:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Get the glider's position over the time.\n", + "x_euler = u_euler[:, 2]\n", + "y_euler = u_euler[:, 3]\n", + "x_rk2 = u_rk2[:, 2]\n", + "y_rk2 = u_rk2[:, 3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### How far will it fly before touching the ground?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the $y$-axis measures the vertical coordinate with respect to the ground, negative values of $y$ don't have any physical meaning: the glider would have hit the ground by then! To find out if there are any negative $y$ values we can use the handy function [`numpy.where`](http://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html). This function returns the **indices** of the elements in an array that match a given condition. For example, `numpy.where(y_euler<0)[0]` gives an array of the indices `i` where `y_euler[i]<0` (the `[0]` is necessary as `numpy.where` returns an array, which in this case contains a single line). If no elements of the array match the condition, the array of indices comes out empty. \n", + "\n", + "From the physical problem, we know that once there is one negative value, the glider has hit the ground and all the remaining time-steps are unphysical. Therefore, we are interested in finding the _first_ index where the condition applies, given by `numpy.where(y_euler<0)[0][0]`—do read the documentation of the function if you need to! " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Get the index of the first negative element of y_euler.\n", + "idx_negative_euler = numpy.where(y_euler < 0.0)[0]\n", + "if len(idx_negative_euler) == 0:\n", + " idx_ground_euler = N - 1\n", + " print('[Euler] Glider has not touched ground yet!')\n", + "else:\n", + " idx_ground_euler = idx_negative_euler[0]\n", + "# Get the index of the first negative element of y_rk2.\n", + "idx_negative_rk2 = numpy.where(y_rk2 < 0.0)[0]\n", + "if len(idx_negative_rk2) == 0:\n", + " idx_ground_rk2 = N - 1\n", + " print('[RK2] Glider has not touched ground yet!')\n", + "else:\n", + " idx_ground_rk2 = idx_negative_rk2[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Do Euler and RK2 produce the same solution?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An easy way to compare the numerical results obtained with the Euler and 2nd-order Runge-Kutta methods is using [`numpy.allclose`](http://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html). This function compares each element of two arrays and returns `True` if each comparison is within some relative tolerance. Here, we use the default tolerance: $10^{-5}$." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Are the x-values close? False\n", + "Are the y-values close? False\n" + ] + } + ], + "source": [ + "# Check if to two scheme leads to the same numerical solution.\n", + "print('Are the x-values close? {}'.format(numpy.allclose(x_euler, x_rk2)))\n", + "print('Are the y-values close? {}'.format(numpy.allclose(y_euler, y_rk2)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hmmm, they do differ. Maybe $10^{-5}$ is too tight a tolerance, considering we're using a somewhat coarse grid with first- and second-order methods. Perhaps we can assess this visually, by plotting the glider's path? Study the code below, where we are plotting the path twice, taking a closer look in the second plot by \"zooming in\" to the beginning of the flight." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance traveled: 14.516\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print('Distance traveled: {:.3f}'.format(x_rk2[idx_ground_rk2 - 1]))\n", + "\n", + "# Plot the glider's path for both schemes.\n", + "pyplot.figure(figsize=(9.0, 6.0))\n", + "pyplot.subplot(121)\n", + "pyplot.grid()\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('y')\n", + "pyplot.plot(x_euler[:idx_ground_euler], y_euler[:idx_ground_euler],\n", + " label='Euler')\n", + "pyplot.plot(x_rk2[:idx_ground_rk2], y_rk2[:idx_ground_rk2],\n", + " label='RK2')\n", + "pyplot.legend();\n", + "# Let's take a closer look!\n", + "pyplot.subplot(122)\n", + "pyplot.grid()\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('y')\n", + "pyplot.plot(x_euler, y_euler, label='Euler')\n", + "pyplot.plot(x_rk2, y_rk2, label='RK2')\n", + "pyplot.xlim(0.0, 5.0)\n", + "pyplot.ylim(1.8, 2.5);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From far away, the Euler and RK2 methods seem to be producing similar answers. However, if we take a closer look, small differences become evident. Keep in mind that we are solving the same equation and both methods will converge to the same solution as we refine the grid. However, they converge to that solution at different rates: RK2 gets more accurate faster, as you make $\\Delta t$ smaller." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Grid-convergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just like in [Lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb), we want to do a grid-convergence study with RK2, to see if we indeed observe the expected rate of convergence. It is always an important step in a numerical solution to investigate whether the method is behaving the way we expect it to: this needs to be confirmed experimentally for every new problem we solve and for every new method we apply!\n", + "\n", + "In the code below, a `for`-loop computes the solution on different time grids, with the coarsest and finest grid differing by 100x. We can use the difference between solutions to investigate convergence, as before." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the list of time-step sizes to investigate.\n", + "dt_values = [0.1, 0.05, 0.01, 0.005, 0.001]\n", + "\n", + "# Create an empty list to store the solution for each time-step size.\n", + "u_values = []\n", + "\n", + "for dt in dt_values:\n", + " N = int(T / dt) + 1 # number of time steps\n", + " # Set initial conditions.\n", + " u = numpy.empty((N, 4))\n", + " u[0] = numpy.array([v0, theta0, x0, y0])\n", + " # Time integration using RK2 method.\n", + " for n in range(N - 1):\n", + " u[n + 1] = rk2_step(u[n], rhs_phugoid, dt, CL, CD, g, vt)\n", + " u_values.append(u)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once those runs are done, we compute the difference between each numerical solution and the fine-grid solution." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute the differences in the x-position for all grids.\n", + "diff_values = []\n", + "for u, dt in zip(u_values, dt_values):\n", + " diff = l1_diff(u[:, 2], u_values[-1][:, 2], dt)\n", + " diff_values.append(diff)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And now we plot!" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot difference versus the time-step size.\n", + "pyplot.figure(figsize=(6.0, 6.0))\n", + "pyplot.title('L1-norm of the difference vs. time-step size')\n", + "pyplot.xlabel('$\\Delta t$')\n", + "pyplot.ylabel('Difference')\n", + "pyplot.grid()\n", + "pyplot.loglog(dt_values[:-1], diff_values[:-1],\n", + " color='C0', linestyle='--', marker='o')\n", + "pyplot.axis('equal');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is looking good! The difference relative to our fine-grid solution is decreasing with the mesh size at a faster rate than in [Lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb), but *how much faster?* When we computed the observed order of convergence with Euler's method, we got a value close to 1—it's a first-order method. Can you guess what we'll get now with RK2?\n", + "\n", + "To compute the observed order of convergence, we use three grid resolutions that are refined at a constant rate, in this case $r=2$. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Observed order of convergence: p = 1.996\n" + ] + } + ], + "source": [ + "r = 2 # time-step size refinement ratio\n", + "h = 0.001 # finest time-step size\n", + "\n", + "dt_values = [h, r * h, r**2 * h]\n", + "u_values = []\n", + "\n", + "for dt in dt_values:\n", + " N = int(T / dt) + 1 # number of time steps\n", + " # Set initial conditions.\n", + " u = numpy.empty((N, 4))\n", + " u[0] = numpy.array([v0, theta0, x0, y0])\n", + " # Time integration using RK2.\n", + " for n in range(N - 1):\n", + " u[n + 1] = rk2_step(u[n], rhs_phugoid, dt, CL, CD, g, vt)\n", + " # Store the solution for the present time grid.\n", + " u_values.append(u)\n", + "\n", + "# Compute the observed order of convergence.\n", + "p = (math.log(l1_diff(u_values[2], u_values[1], dt_values[2]) /\n", + " l1_diff(u_values[1], u_values[0], dt_values[1])) /\n", + " math.log(r))\n", + "\n", + "print('Observed order of convergence: p = {:.3f}'.format(p))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Probably you're not too surprised to see that the observed order of convergence is close to $2$. Because we used a second-order method! This means that the numerical solution is converging with the grid resolution twice as fast compared with Euler's method in [Lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb), or in other words, the error scales as ${\\mathcal O}(\\Delta t^2)$. That is a lot faster! However, we are paying a price here: second-order Runge-Kutta requires more computations per iteration." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Challenge task" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "How much longer does it take to get the solution with RK2, compared to Euler's method? Run the same solution (same time grid, same parameters), but find a way to *time* the calculation with Python, and compare the runtimes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multi-step methods" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The screencast *\"Euler's method is a first-order method\"* motivated graphically an idea to get increased accuracy: using intermediate points between $u_{n}$ and $u_{n+1}$ and evaluating the right-hand side of the differential equation at those intermediate points. The idea is to somehow get a better approximation using more data from the function $f(u)$.\n", + "\n", + "Another way to bring more information about $f(u)$ into the numerical solution is to look at time data $t\\lt t_{n}$. For example, we can involve in the calculation of the solution $u_{n+1}$ the known solution at $u_{n-1}$, in addition to $u_{n}$. Schemes that use this idea are called _multi-step methods_.\n", + "\n", + "\n", + "A classical multi-step method achieves second order by applying a _centered difference_ approximation of the derivative $u'$:\n", + "\n", + "$$\n", + "u'(t) \\approx \\frac{u_{n+1} - u_{n-1}}{2\\Delta t}\n", + "$$\n", + "\n", + "Isolate the future value of the solution $u_{n+1}$ and apply the differential equation $u'=f(u)$, to get the following formula for this method:\n", + "\n", + "$$\n", + "u_{n+1} = u_{n-1} + 2\\Delta t \\, f(u_n)\n", + "$$\n", + "\n", + "This scheme is known as the **leapfrog method**. Notice that it is using the right-hand side of the differential equation, $f(u)$, evaluated at the _midpoint_ between $u_{n-1}$ and $u_{n+1}$, where the time interval between these two solutions is $2\\Delta t$. Why is it called \"leapfrog\"? If you imagine for a moment all of the _even_ indices $n$ of the numerical solution, you notice that these solution values are computed using the slope estimated from _odd_ values $n$, and vice-versa.\n", + "\n", + "Let's define a function that computes the numerical solution using the leapfrog method:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def leapfrog_step(u_prev, u, f, dt, *args):\n", + " \"\"\"\n", + " Returns the solution at the next time step using \n", + " the leapfrog method.\n", + " \n", + " Parameters\n", + " ----------\n", + " u_prev : numpy.ndarray\n", + " Solution at the time step n-1\n", + " as a 1D array of floats.\n", + " u : numpy.ndarray\n", + " Solution at the previous time step\n", + " as a 1D array of floats.\n", + " f : function\n", + " Function to compute the right-hand side of the system.\n", + " dt : float\n", + " Time-step size.\n", + " args : tuple, optional\n", + " Positional arguments to pass to the function f.\n", + " \n", + " Returns\n", + " -------\n", + " u_new : numpy.ndarray\n", + " The solution at the next time step\n", + " as a 1D array of floats.\n", + " \"\"\"\n", + " u_new = u_prev + 2.0 * dt * f(u, *args)\n", + " return u_new" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But wait ... what will we do at the _initial_ time step, when we don't have information for $u_{n-1}$? This is an issue with all multi-step methods: we say that they are _not self-starting_. In the first time step, we need to use another method to get the first \"kick\"—either Euler's method or 2nd-order Runge Kutta could do: let's use RK2, since it's also second order.\n", + "\n", + "For this calculation, we are going to re-enter the model parameters in the code cell below, so that later on we can experiment here using the leapfrog method and different starting values. At the end of this notebook, we'll give you some other model parameters to try that will create a very interesting situation!" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "g = 9.81 # gravitational acceleration (m.s^{-2})\n", + "vt = 4.9 # trim velocity (m.s)\n", + "CD = 1.0 / 5.0 # drag coefficient\n", + "CL = 1.0 # lift coefficient\n", + "\n", + "# Set initial conditions.\n", + "v0 = 6.5 # start at the trim velocity\n", + "theta0 = -0.1 # trajectory angle\n", + "x0 = 0.0 # horizontal position\n", + "y0 = 2.0 # vertical position (altitude)\n", + "\n", + "T = 15.0 # length of the time interval\n", + "dt = 0.01 # time-step size\n", + "N = int(T / dt) + 1 # number of time steps\n", + "\n", + "# Create arrays to store the solution at each time step.\n", + "u_leapfrog = numpy.empty((N, 4))\n", + "# Set the initial conditions.\n", + "u_leapfrog[0] = numpy.array([v0, theta0, x0, y0])\n", + "# Use the RK2 method for the first time step.\n", + "u_leapfrog[1] = rk2_step(u_leapfrog[0], rhs_phugoid, dt, CL, CD, g, vt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have all the required information to loop in time using the leapfrog method. The code cell below calls the leapfrog function for each time step." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Time integration using the leapfrog method.\n", + "for n in range(1, N - 1):\n", + " u_leapfrog[n + 1] = leapfrog_step(u_leapfrog[n - 1], u_leapfrog[n],\n", + " rhs_phugoid, dt, CL, CD, g, vt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Like before, we extract from the solution array the information about the glider's position in time and find where it reaches the ground." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# Get the glider's position over the time.\n", + "x_leapfrog = u_leapfrog[:, 2]\n", + "y_leapfrog = u_leapfrog[:, 3]\n", + "\n", + "# Get the index of the first negative element of y_leapfrog.\n", + "idx_negative_leapfrog = numpy.where(y_leapfrog < 0.0)[0]\n", + "if len(idx_negative_leapfrog) == 0:\n", + " idx_ground_leapfrog = N - 1\n", + " print('[leapfrog] Glider has not touched ground yet!')\n", + "else:\n", + " idx_ground_leapfrog = idx_negative_leapfrog[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting the glider's trajectory with both the leapfrog and RK2 methods, we find that the solutions are very close to each other now: we don't see the differences that were apparent when we compared Euler's method and RK2." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance traveled: 14.516\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print('Distance traveled: {:.3f}'.format(x_leapfrog[idx_ground_leapfrog - 1]))\n", + "\n", + "# Plot the glider's path for the leapfrog scheme.\n", + "pyplot.figure(figsize=(9.0, 6.0))\n", + "pyplot.subplot(121)\n", + "pyplot.grid()\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('y')\n", + "pyplot.plot(x_leapfrog[:idx_ground_leapfrog],\n", + " y_leapfrog[:idx_ground_leapfrog])\n", + "# Let's take a closer look!\n", + "pyplot.subplot(122)\n", + "pyplot.grid()\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('y')\n", + "pyplot.plot(x_leapfrog, y_leapfrog)\n", + "pyplot.xlim(0.0, 5.0)\n", + "pyplot.ylim(1.8, 2.5);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What about the observed order of convergence? We'll repeat the process we have used before, with a grid-refinement ratio $r=2$ ... here we go:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Observed order of convergence: p = 2.187\n" + ] + } + ], + "source": [ + "r = 2 # time-step size refinement ratio\n", + "h = 0.001 # finest time-step size\n", + "\n", + "dt_values = [h, r * h, r**2 * h]\n", + "u_values = []\n", + "\n", + "for dt in dt_values:\n", + " N = int(T / dt) + 1 # number of time steps\n", + " # Set initial conditions.\n", + " u = numpy.empty((N, 4))\n", + " u[0] = numpy.array([v0, theta0, x0, y0])\n", + " # Use RK2 for the first time step.\n", + " u[1] = rk2_step(u[0], rhs_phugoid, dt, CL, CD, g, vt)\n", + " # Time integration using the leapfrog scheme.\n", + " for n in range(1, N - 1):\n", + " u[n + 1] = leapfrog_step(u[n - 1], u[n], rhs_phugoid, dt,\n", + " CL, CD, g, vt)\n", + " # Store the solution for the present time grid.\n", + " u_values.append(u)\n", + "\n", + "# Compute the observed order of convergence.\n", + "p = (math.log(l1_diff(u_values[2][:, 2], u_values[1][:, 2],\n", + " dt_values[2]) /\n", + " l1_diff(u_values[1][:, 2], u_values[0][:, 2],\n", + " dt_values[1])) /\n", + " math.log(r))\n", + "\n", + "print('Observed order of convergence: p = {:.3f}'.format(p))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now have numerical evidence that our calculation with the leapfrog method indeed exhibits second-order convergence, i.e., the method is ${\\mathcal O}(\\Delta t^2)$. _The leapfrog method is a second-order method_. Good job!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### But chew on this ..." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Go back to the cell that re-enters the model parameters, just above the leapfrog-method time loop, and change the following: the initial height `y0` to 25, and the final time `T` to 36. Now re-run the leapfrog calculation and the two code cells below that, which extract the glider's position and plot it.\n", + "\n", + "_What is going on?_\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reference" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tobies, R. \"Iris Runge: A life at the crossroads of mathematics, science and industry,\" Springer Basel, 1st ed. (2012). [Read on Google books, page 73](http://books.google.com/books?id=EDm0eQqFUQ4C&lpg=PA73&dq=%22I%20have%20been%20making%20good%20progress%20with%20Lanchester.%20The%20second%20chapter%20is%20already%20on%20your%20desk%22&pg=PA73#v=onepage&q=%22I%20have%20been%20making%20good%20progress%20with%20Lanchester.%20The%20second%20chapter%20is%20already%20on%20your%20desk%22&f=false)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/01_phugoid/README.md b/2-finite-difference-method/lessons/01_phugoid/README.md new file mode 100644 index 0000000..d46e4f5 --- /dev/null +++ b/2-finite-difference-method/lessons/01_phugoid/README.md @@ -0,0 +1,43 @@ +# Module 1: The phugoid model of glider flight. + +## Summary + +The phugoid model motivates the learning of numerical time integration methods. The model is described by a set of two nonlinear ordinary differential equations, representing the oscillatory trajectory of an aircraft subject to longitudinal perturbations. + +* [Lesson 1](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_01_Phugoid_Theory.ipynb) presents the physics of phugoids in the assumption of zero drag (following Lanchester, 1909). Plotting the flight path gives fascinating curve shapes. +* [Lesson 2](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_02_Phugoid_Oscillation.ipynb) develops a single-equation model for zero-drag oscillations, leading to simple harmonic motion. The lesson defines initial-value problems, demonstrates Euler's method, and uses the exact solution to study the numerical convergence. +* [Lesson 3](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb) develops the full phugoid model and solves it with (vectorized) Euler's method. In the absence of an exact solution, the study of convergence uses a grid-refinement method, obtaining the observed order of convergence. The lesson ends with the paper-airplane challenge. +* [Lesson 4](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_04_Second_Order_Methods.ipynb) starts with the screencast "Euler's method is a first-order method" and develops second-order methods: explicit midpoint (modified Euler) and Runge-Kutta. It ends with a grid-refinement study. + +## Badge earning + +Completion of this module in the online course platform can earn the learner the Module 1 badge. + +### Description: What does this badge represent? + +The earner completed Module 1 "The phugoid model of glider flight" of the course "Practical Numerical Methods with Python" (a.k.a., numericalmooc). + +### Criteria: What needs to be done to earn it? + +To earn this badge, the learner needs to complete the graded assessment in the course platform including: answering quiz about basic numerical Python commands; answering quiz about basics of initial-value problems; completing the individual coding assignment "Rocket flight" and answering the numeric questions online. Earners should also have completed self-study of the four module lessons, by reading, reflecting on and writing their own version of the codes. This is not directly assessed, but it is assumed. Thus, earners are encouraged to provide evidence of this self-study by giving links to their code repositories or other learning objects they created in the process. + +### Evidence: Website (link to original digital content) + +Desirable: link to the earner's GitHub repository (or equivalent) containing the solution to the "Rocket flight" coding assignment. +Optional: link to the earner's GitHub repository (or equivalent) containing other codes, following the lesson. + +### Category: + +Higher education, graduate + +### Tags: + +engineering, computation, higher education, numericalmooc, python, gwu, george washington university, lorena barba, github + +### Relevant Links: Is there more information on the web? + +[Course About page](http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/about) + +[Course Wiki](http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/wiki/GW.MAE6286.2014_fall/) + +[Course GitHub repo](https://github.com/numerical-mooc/numerical-mooc) diff --git a/2-finite-difference-method/lessons/01_phugoid/Rocket_Assignment.ipynb b/2-finite-difference-method/lessons/01_phugoid/Rocket_Assignment.ipynb new file mode 100644 index 0000000..486d35d --- /dev/null +++ b/2-finite-difference-method/lessons/01_phugoid/Rocket_Assignment.ipynb @@ -0,0 +1,350 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Coding Assignment: Rocket" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The equations of motion for a rocket in purely vertical flight are given by\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\frac{dh}{dt} &= v\\\\\n", + "(m_s+m_p) \\frac{dv}{dt}& = -(m_s+m_p)g + \\dot{m}_pv_e - \\frac{1}{2}\\rho v|v|AC_D\n", + "\\end{align}\n", + "$$\n", + "\n", + "$h$ is the altitude of the rocket\n", + "\n", + "$m_s = 50kg$ is the weight of the rocket shell\n", + "\n", + "$g = 9.81 \\frac{m}{s^2}$\n", + "\n", + "$\\rho = 1.091 \\frac{kg}{m^3}$ is the average air density (assumed constant throughout flight)\n", + "\n", + "$A = \\pi r^2$ is the maximum cross sectional area of the rocket, where $r = 0.5 m$\n", + "\n", + "$v_e = 325 \\frac{m}{s}$ is the exhaust speed\n", + "\n", + "$C_D = 0.15 $ is the drag coefficient\n", + "\n", + "$m_{po} = 100 kg$ at time $t = 0$ is the initial weight of the rocket propellant\n", + "\n", + "The mass of the remaining propellant is given by:\n", + "\n", + "$$m_p = m_{po} - \\int^t_0 \\dot{m}_p d\\tau$$\n", + "\n", + "where $\\dot{m}_p$ is the time-varying burn rate given by the following figure:\n", + "\n", + "Propellant Burn Rate\n", + "\n", + "![burn rate](./figures/burn_rate.png)\n", + "\n", + "that is,\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\dot{m}_p \\left( t \\right) =\n", + " \\begin{cases}\n", + " 20 & \\quad \\text{if} \\quad t < 5 \\\\\n", + " 0 & \\quad \\text{otherwise}\n", + " \\end{cases}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Using Euler's method with a time-step size of $\\Delta t=0.1s$, create a Python script to calculate the altitude and velocity of the rocket from launch until crash down." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Assessment:\n", + "\n", + "To check your answers, you can register for [MAE 6286: Practical Numerical Methods with Python](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about).\n", + "\n", + "1. At time $t=3.2s$, what is the mass (in kg) of rocket propellant remaining in the rocket?\n", + "\n", + "2. What is the maximum speed of the rocket in $\\frac{m}{s}$?\n", + " At what time does this occur (in seconds)? \n", + " What is the altitude at this time (in meters)? \n", + " \n", + "3. What is the rocket's maximum altitude during flight (in meters)? At what time (in seconds) does this occur?\n", + "\n", + "4. At what time (in seconds) does the rocket impact the ground? What is the velocity of the rocket (in $\\frac{m}{s}$) at time of impact?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Derivation of the rocket equations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In case you are kind of confused about the rocket equations, here we show how to get to them. \n", + "\n", + "Newton's second law states that the acceleration of the vehicle times its mass is equal to all the forces acting on it. Therefore,\n", + "\n", + "\\begin{equation}\n", + "(m_s + m_p)\\frac{d\\bf{v}}{dt}=\\sum {\\bf F}.\n", + "\\end{equation}\n", + "In the above formula we have assumed that the propellant inside the rocket and the rocket move at the same velocity (in other words, their relative velocity is negligible). \n", + "\n", + "Two of the external forces acting on the rocket are,\n", + "\n", + "\\begin{align}\n", + "{\\bf F}_g&= (m_s+m_p)\\bf{g} \\quad (\\rm{Gravity}),\\\\\n", + "{\\bf F}_d&= - \\frac{1}{2} \\rho_a \\mathbf{v} |\\mathbf{v}| A C_D \\quad (\\rm{Drag}).\n", + "\\end{align}\n", + "\n", + "We also need to consider the force resulting from the ejection of the propellant. During an interval $dt$, the engine of the rocket ejects downwards a mass of propellant given by $\\dot m_p dt$. Relative to the rocket, the speed of the ejected burning gas is assumed constant and equal to $v_e$ (the exhaust speed). The momentum variation induced on the exhaust gas by the engine during that interval is therefore, $d{\\bf p}_{gas} = \\dot m_p {\\bf v}_e dt$. Again using Newton's second law we conclude that the force applied by the rocket on the gas is,\n", + "\n", + "\\begin{align}\n", + "{\\bf F}_{rocket\\rightarrow gas} = \\frac{d{\\bf p}_{gas}}{dt} = \\dot m_p {\\bf v}_e\n", + "\\end{align}\n", + "\n", + "Using Newton's third law (|action| = |reaction|), the force exerted by the exhaust gas on the rocket is then,\n", + "\n", + "\\begin{align}\n", + "{\\bf F}_{gas\\rightarrow rocket} = -{\\bf F}_{rocket\\rightarrow gas} = -\\dot m_p {\\bf v}_e\n", + "\\end{align}\n", + "\n", + "If we collect all the forces acting on the rocket we finally have:\n", + "\n", + "\\begin{align}\n", + "(m_s + m_p)\\frac{d\\bf{v}}{dt}=(m_s+m_p){\\bf g}- \\frac{1}{2} \\rho_a \\mathbf{v} |v| A C_D -\\dot m_p {\\bf v}_e\n", + "\\end{align}\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/01_phugoid/figures/burn_rate.png b/2-finite-difference-method/lessons/01_phugoid/figures/burn_rate.png new file mode 100644 index 0000000..d2cd935 Binary files /dev/null and b/2-finite-difference-method/lessons/01_phugoid/figures/burn_rate.png differ diff --git a/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces-lesson3.png b/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces-lesson3.png new file mode 100644 index 0000000..6d73dd7 Binary files /dev/null and b/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces-lesson3.png differ diff --git a/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces.png b/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces.png new file mode 100644 index 0000000..ac036d5 Binary files /dev/null and b/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces.png differ diff --git a/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces_fbd.svg b/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces_fbd.svg new file mode 100644 index 0000000..47a1d34 --- /dev/null +++ b/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces_fbd.svg @@ -0,0 +1,465 @@ + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + trajectory + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces_nodrag.png b/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces_nodrag.png new file mode 100644 index 0000000..969042c Binary files /dev/null and b/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces_nodrag.png differ diff --git a/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces_nodrag.svg b/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces_nodrag.svg new file mode 100644 index 0000000..00942f4 --- /dev/null +++ b/2-finite-difference-method/lessons/01_phugoid/figures/glider_forces_nodrag.svg @@ -0,0 +1,368 @@ + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + trajectory + diff --git a/2-finite-difference-method/lessons/01_phugoid/figures/oscillatory_trajectory.png b/2-finite-difference-method/lessons/01_phugoid/figures/oscillatory_trajectory.png new file mode 100644 index 0000000..6e7dca9 Binary files /dev/null and b/2-finite-difference-method/lessons/01_phugoid/figures/oscillatory_trajectory.png differ diff --git a/2-finite-difference-method/lessons/01_phugoid/figures/rocket_CV.png b/2-finite-difference-method/lessons/01_phugoid/figures/rocket_CV.png new file mode 100644 index 0000000..5686f4f Binary files /dev/null and b/2-finite-difference-method/lessons/01_phugoid/figures/rocket_CV.png differ diff --git a/2-finite-difference-method/lessons/01_phugoid/figures/vonKarman-phugoids.png b/2-finite-difference-method/lessons/01_phugoid/figures/vonKarman-phugoids.png new file mode 100644 index 0000000..e3c6414 Binary files /dev/null and b/2-finite-difference-method/lessons/01_phugoid/figures/vonKarman-phugoids.png differ diff --git a/2-finite-difference-method/lessons/01_phugoid/phugoid.py b/2-finite-difference-method/lessons/01_phugoid/phugoid.py new file mode 100755 index 0000000..1a94e10 --- /dev/null +++ b/2-finite-difference-method/lessons/01_phugoid/phugoid.py @@ -0,0 +1,133 @@ +""" +Implementation of the functions to compute and plot the flight path of the +phugoid using Lanchester's mode. +The implementation uses the sign convention and formula provided by +Milne-Thomson (1958). +""" + +import numpy +from matplotlib import pyplot + + +# Ignore over/underflow errors that pop up in the `radius_of_curvature` +# function. +# (See http://docs.scipy.org/doc/numpy/reference/generated/numpy.seterr.html +# for more explanations.) +numpy.seterr(all='ignore') + + +def radius_of_curvature(z, zt, C): + """ + Returns the radius of curvature of the flight path at any point. + + Parameters + ---------- + z : float + Current depth below the reference horizontal line. + zt : float + Initial depth below the reference horizontal line. + C : float + Constant of integration. + + Returns + ------- + radius : float + Radius of curvature. + """ + return zt / (1 / 3 - C / 2 * (zt / z)**1.5) + + +def rotate(coords, center=(0.0, 0.0), angle=0.0, mode='degrees'): + """ + Rotates a point or an array of points + by a given angle around a given center point. + + Parameters + ---------- + coords :tuple + Current x and z positions of the point(s) + as a tuple of two floats or a tuple of two 1D arrays of floats. + center : tuple, optional + Center of rotation (x, z) as a tuple of two floats; + default: (0.0, 0.0). + angle : float, optional + Angle of rotation; + default: 0.0. + mode : string, optional + Set if angle given in degrees or radians; + choices: ['degrees', 'radians']; + default: 'degrees'. + + Returns + ------- + x_new : float or numpy.ndarray + x position of the rotated point(s) + as a single float or a 1D array of floats. + z_new : float or numpy.ndarray + z position of the rotated point(s) + as a single float or a 1D array of floats. + """ + x, z = coords + xc, zc = center + if mode == 'degrees': + angle = numpy.radians(angle) + x_new = xc + (x - xc) * numpy.cos(angle) + (z - zc) * numpy.sin(angle) + z_new = zc - (x - xc) * numpy.sin(angle) + (z - zc) * numpy.cos(angle) + return x_new, z_new + + +def plot_flight_path(zt, z0, theta0, N=1000): + """ + Plots the flight path of the glider. + + Parameters + ---------- + zt : float + Trim height of the glider. + z0 : float + Initial height of the glider. + theta0 : float + Initial orientation of the glider (in degrees). + N : integer, optional + Number of points used to discretize the path; + default: 1000. + """ + # Convert initial angle to radians. + theta0 = numpy.radians(theta0) + # Create arrays to store the coordinates of the flight path. + x, z = numpy.zeros(N), numpy.zeros(N) + # Set initial conditions. + x[0], z[0], theta = 0.0, z0, theta0 + # Calculate the constant of integration C. + C = (numpy.cos(theta) - 1 / 3 * z[0] / zt) * (z[0] / zt)**0.5 + # Set incremental distance along the flight path. + ds = 1.0 + # Calculate coordinates along the path. + for i in range(1, N): + # We use a minus sign for the second coordinate of the normal vector + # because the z-axis points downwards. + normal = numpy.array([+ numpy.cos(theta + numpy.pi / 2.0), + - numpy.sin(theta + numpy.pi / 2.0)]) + # Get curvature radius and compute center of rotation. + R = radius_of_curvature(z[i - 1], zt, C) + center = numpy.array([x[i - 1], z[i - 1]]) + R * normal + # Set angular increment. + dtheta = ds / R + # Calculate new position and update angle. + x[i], z[i] = rotate((x[i - 1], z[i - 1]), + center=center, angle=dtheta, mode='radians') + theta += dtheta + # Set the font family and size to use for Matplotlib figures. + pyplot.rcParams['font.family'] = 'serif' + pyplot.rcParams['font.size'] = 16 + # Create Matplotlib figure. + fig, ax = pyplot.subplots(figsize=(9.0, 4.0)) + ax.grid() + ax.set_title(f'Flight path for $C={C:.3f}$\n' + + rf'($z_t={zt:.1f}$, $z_0={z0:.1f}$, ' + + rf'$\theta_0={numpy.degrees(theta0):.1f}^o$)') + ax.set_xlabel(r'$x$') + ax.set_ylabel(r'$z$') + ax.plot(x, -z, linestyle='-', linewidth=2.0) + ax.axis('scaled', adjustable='box') + pyplot.show() diff --git a/2-finite-difference-method/lessons/02_spacetime/02_01_1DConvection.ipynb b/2-finite-difference-method/lessons/02_spacetime/02_01_1DConvection.ipynb new file mode 100644 index 0000000..242d621 --- /dev/null +++ b/2-finite-difference-method/lessons/02_spacetime/02_01_1DConvection.ipynb @@ -0,0 +1,958 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth, C.D. Cooper. Based on [CFD Python](https://github.com/barbagroup/CFDPython), (c)2013 L.A. Barba, also under CC-BY." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Space & Time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction to numerical solution of PDEs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome to *Space and Time: Introduction to finite-difference solutions of PDEs*, the second module of [\"Practical Numerical Methods with Python\"](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about). \n", + "\n", + "In the first module, we looked into numerical integration methods for the solution of ordinary differential equations (ODEs), using the phugoid model of glider flight as a motivation. In this module, we will study the numerical solution of *partial differential equations (PDEs)*, where the unknown is a multi-variate function. The problem could depend on time, $t$, and one spatial dimension $x$ (or more), which means we need to build a discretization grid with each independent variable.\n", + "\n", + "We will start our discussion of numerical PDEs with 1-D linear and non-linear convection equations, the 1-D diffusion equation, and 1-D Burgers' equation. We hope you will enjoy them!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1D linear convection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The *one-dimensional linear convection equation* is the simplest, most basic model that can be used to learn something about numerical solution of PDEs. It's surprising that this little equation can teach us so much! Here it is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial u}{\\partial t} + c \\frac{\\partial u}{\\partial x} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The equation represents a *wave* propagating with speed $c$ in the $x$ direction, without change of shape. For that reason, it's sometimes called the *one-way wave equation* (sometimes also the *advection equation*).\n", + "\n", + "With an initial condition $u(x,0)=u_0(x)$, the equation has an exact solution given by:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u(x,t)=u_0(x-ct)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Go on: check it. Take the time and space derivative and stick them into the equation to see that it holds!\n", + "\n", + "Look at the exact solution for a moment ... we know two things about it: \n", + "\n", + "1. its shape does not change, being always the same as the initial wave, $u_0$, only shifted in the $x$-direction; and \n", + "2. it's constant along so-called **characteristic curves**, $x-ct=$constant. This means that for any point in space and time, you can move back along the characteristic curve to $t=0$ to know the value of the solution." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![characteristics](figures/characteristics.png)\n", + "#### Characteristic curves for positive wave speed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Why do we call the equations *linear*? PDEs can be either linear or non-linear. In a linear equation, the unknown function $u$ and its derivatives appear only in linear terms, in other words, there are no products, powers, or transcendental functions applied on them. \n", + "\n", + "What is the most important feature of linear equations? Do you remember? In case you forgot: solutions can be superposed to generate new solutions that still satisfy the original equation. This is super useful!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Finite-differences" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the previous lessons, we discretized time derivatives; now we have derivatives in both space *and* time, so we need to discretize with respect to *both* these variables. \n", + "\n", + "Imagine a *space-time* plot, where the coordinates in the vertical direction represent advancing in time—for example, from $t^n$ to $t^{n+1}$—and the coordinates in the horizontal direction move in space: consecutive points are $x_{i-1}$, $x_i$, and $x_{i+1}$. This creates a grid where a point has both a temporal and spatial index. Here is a graphical representation of the space-time grid:\n", + "\n", + "$$\n", + "\\begin{matrix}\n", + "t^{n+1} & \\rightarrow & \\bullet && \\bullet && \\bullet \\\\\n", + "t^n & \\rightarrow & \\bullet && \\bullet && \\bullet \\\\\n", + "& & x_{i-1} && x_i && x_{i+1}\n", + "\\end{matrix}\n", + "$$\n", + "\n", + "For the numerical solution of $u(x,t)$, we'll use subscripts to denote the spatial position, like $u_i$, and superscripts to denote the temporal instant, like $u^n$. We would then label the solution at the top-middle point in the grid above as follows:\n", + "$u^{n+1}_{i}$.\n", + "\n", + "Each grid point below has an index $i$, corresponding to the spatial position and increasing to the right, and an index $n$, corresponding to the time instant and increasing upwards. A small grid segment would have the following values of the numerical solution at each point:\n", + "\n", + "$$\n", + "\\begin{matrix}\n", + "& &\\bullet & & \\bullet & & \\bullet \\\\\n", + "& &u^{n+1}_{i-1} & & u^{n+1}_i & & u^{n+1}_{i+1} \\\\\n", + "& &\\bullet & & \\bullet & & \\bullet \\\\\n", + "& &u^n_{i-1} & & u^n_i & & u^n_{i+1} \\\\\n", + "& &\\bullet & & \\bullet & & \\bullet \\\\\n", + "& &u^{n-1}_{i-1} & & u^{n-1}_i & & u^{n-1}_{i+1} \\\\\n", + "\\end{matrix}\n", + "$$\n", + "\n", + "Another way to explain our discretization grid is to say that it is built with constant steps in time and space, $\\Delta t$ and $\\Delta x$, as follows:\n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "x_i &=& i\\, \\Delta x \\quad \\text{and} \\quad t^n= n\\, \\Delta t \\nonumber \\\\\n", + "u_i^n &=& u(i\\, \\Delta x, n\\, \\Delta t)\n", + "\\end{eqnarray}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Discretizing our model equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see how to discretize the 1-D linear convection equation in both space and time. By definition, the partial derivative with respect to time changes only with time and not with space; its discretized form changes only the $n$ indices. Similarly, the partial derivative with respect to $x$ changes with space not time, and only the $i$ indices are affected. \n", + "\n", + "We'll discretize the spatial coordinate $x$ into points indexed from $i=0$ to $N$, and then step in discrete time intervals of size $\\Delta t$.\n", + "\n", + "From the definition of a derivative (and simply removing the limit), we know that for $\\Delta x$ sufficiently small:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial u}{\\partial x}\\approx \\frac{u(x+\\Delta x)-u(x)}{\\Delta x}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This formula could be applied at any point $x_i$. But note that it's not the only way that we can estimate the derivative. The geometrical interpretation of the first derivative $\\partial u/ \\partial x$ at any point is that it represents the slope of the tangent to the curve $u(x)$. In the sketch below, we show a slope line at $x_i$ and mark it as \"exact.\" If the formula written above is applied at $x_i$, it approximates the derivative using the next spatial grid point: it is then called a _forward difference_ formula. \n", + "\n", + "But as shown in the sketch below, we could also estimate the spatial derivative using the point behind $x_i$, in which case it is called a _backward difference_. We could even use the two points on each side of $x_i$, and obtain what's called a _central difference_ (but in that case the denominator would be $2\\Delta x$)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![FDapproxiamtions](figures/FDapproxiamtions.png)\n", + "#### Three finite-difference approximations at $x_i$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have three possible ways to represent a discrete form of $\\partial u/ \\partial x$:\n", + "\n", + "* Forward difference: uses $x_i$ and $x_i + \\Delta x$,\n", + "* Backward difference: uses $x_i$ and $x_i- \\Delta x$,\n", + "* Central difference: uses two points on either side of $x_i$.\n", + "\n", + "The sketch above also suggests that some finite-difference formulas might be better than others: it looks like the *central difference* approximation is closer to the slope of the \"exact\" derivative. Curious if this is just an effect of our exaggerated picture? We'll show you later how to make this observation rigorous!\n", + "\n", + "The three formulas are:\n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "\\frac{\\partial u}{\\partial x} & \\approx & \\frac{u(x_{i+1})-u(x_i)}{\\Delta x} \\quad\\text{Forward}\\\\\n", + "\\frac{\\partial u}{\\partial x} & \\approx & \\frac{u(x_i)-u(x_{i-1})}{\\Delta x} \\quad\\text{Backward}\\\\\n", + "\\frac{\\partial u}{\\partial x} & \\approx & \\frac{u(x_{i+1})-u(x_{i-1})}{2\\Delta x} \\quad\\text{Central}\n", + "\\end{eqnarray}\n", + "$$\n", + "\n", + "Euler's method is equivalent to using a forward-difference scheme for the time derivative. Let's stick with that, and choose the backward-difference scheme for the space derivative. Our discrete equation is then:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{u_i^{n+1}-u_i^n}{\\Delta t} + c \\frac{u_i^n - u_{i-1}^n}{\\Delta x} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $n$ and $n+1$ are two consecutive steps in time, while $i-1$ and $i$ are two neighboring points of the discretized $x$ coordinate. With given initial conditions, the only unknown in this discretization is $u_i^{n+1}$. We solve for this unknown to get an equation that lets us step in time, as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u_i^{n+1} = u_i^n - c \\frac{\\Delta t}{\\Delta x}(u_i^n-u_{i-1}^n)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We like to make drawings of a grid segment, showing the grid points that influence our numerical solution. This is called a **stencil**. Below is the stencil for solving our model equation with the finite-difference formula we wrote above." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![FTBS_stencil](figures/FTBS_stencil.png)\n", + "#### Stencil for the \"forward-time/backward-space\" scheme." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## And compute!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alright. Let's get a little Python on the road. First: we need to load our array and plotting libraries, as usual." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also set notebook-wide plotting parameters for the font family and the font size by modifying entries of the `rcParams` dictionary." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a first exercise, we'll solve the 1D linear convection equation with a *square wave* initial condition, defined as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u(x,0)=\\begin{cases}2 & \\text{where } 0.5\\leq x \\leq 1,\\\\\n", + "1 & \\text{everywhere else in } (0, 2)\n", + "\\end{cases}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We also need a boundary condition on $x$: let $u=1$ at $x=0$. Our spatial domain for the numerical solution will only cover the range $x\\in (0, 2)$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![squarewave](figures/squarewave.png)\n", + "#### Square wave initial condition." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's define a few variables; we want to make an evenly spaced grid of points within our spatial domain. In the code below, we define a variable called `nx` that will be the number of spatial grid points, and a variable `dx` that will be the distance between any pair of adjacent grid points. We also can define a step in time, `dt`, a number of steps, `nt`, and a value for the wave speed: we like to keep things simple and make $c=1$. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "nx = 41 # number of spatial discrete points\n", + "L = 2.0 # length of the 1D domain\n", + "dx = L / (nx - 1) # spatial grid size\n", + "nt = 25 # number of time steps\n", + "dt = 0.02 # time-step size\n", + "c = 1.0 # convection speed\n", + "\n", + "# Define the grid point coordinates.\n", + "x = numpy.linspace(0.0, L, num=nx)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also need to set up our initial conditions. Here, we use the NumPy function `numpy.ones()` defining an array which is `nx`-element long with every value equal to $1$. How useful! We then *change a slice* of that array to the value $u=2$, to get the square wave, and we print out the initial array just to admire it. But which values should we change? The problem states that we need to change the indices of `u` such that the square wave begins at $x = 0.5$ and ends at $x = 1$.\n", + "\n", + "We can use the [`numpy.where()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html) function to return a list of indices where the vector $x$ meets some conditions.\n", + "The function [`numpy.logical_and()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.logical_and.html) computes the truth value of `x >= 0.5` **and** `x <= 1.0`, element-wise." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]),)\n" + ] + } + ], + "source": [ + "# Set initial conditions with 1.0 everywhere (for now).\n", + "u0 = numpy.ones(nx)\n", + "# Get a list of indices where 0.5 <= x <= 1.0.\n", + "mask = numpy.where(numpy.logical_and(x >= 0.5, x <= 1.0))\n", + "print(mask)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the list of indices, we can now update our initial conditions to get a square-wave shape." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 1. 1. 1.\n", + " 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n" + ] + } + ], + "source": [ + "# Set initial condition u = 2.0 where 0.5 <= x <= 1.0.\n", + "u0[mask] = 2.0\n", + "print(u0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's take a look at those initial conditions we've built with a handy plot." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the initial conditions.\n", + "pyplot.figure(figsize=(4.0, 4.0))\n", + "pyplot.title('Initial conditions')\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('u')\n", + "pyplot.grid()\n", + "pyplot.plot(x, u0, color='C0', linestyle='--', linewidth=2)\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 2.5);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It does look pretty close to what we expected. But it looks like the sides of the square wave are not perfectly vertical. Is that right? Think for a bit." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now it's time to write some code for the discrete form of the convection equation using our chosen finite-difference scheme. \n", + "\n", + "For every element of our array `u`, we need to perform the operation: \n", + "\n", + "$$\n", + "u_i^{n+1} = u_i^n - c \\frac{\\Delta t}{\\Delta x}(u_i^n-u_{i-1}^n)\n", + "$$\n", + "\n", + "We'll store the result in a new (temporary) array `un`, which will be the solution $u$ for the next time-step. We will repeat this operation for as many time-steps as we specify and then we can see how far the wave has traveled. \n", + "\n", + "We first initialize the placeholder array `un` to hold the values we calculate for the $n+1$ time step, using once again the NumPy function `ones()`.\n", + "\n", + "Then, we may think we have two iterative operations: one in space and one in time (we'll learn differently later), so we may start by nesting a spatial loop inside the time loop, as shown below. You see that the code for the finite-difference scheme is a direct expression of the discrete equation: " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "u = u0.copy()\n", + "for n in range(1, nt):\n", + " un = u.copy()\n", + " for i in range(1, nx):\n", + " u[i] = un[i] - c * dt / dx * (un[i] - un[i - 1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note 1**—We stressed above that our physical problem needs a boundary condition at $x=0$. Here we do not need to impose it at every iteration because our discretization does not change the value of u[0]: it remains equal to one and our boundary condition is therefore satisfied during the whole computation!\n", + "\n", + "**Note 2**—We will learn later that the code as written above is quite inefficient, and there are better ways to write this, Python-style. But let's carry on.\n", + "\n", + "Now let's inspect our solution array after advancing in time with a line plot." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS8AAAEbCAYAAACLNQJjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl4VOX58PHvnY0khC2EsG8ioCwhAq64RAVErRQq7ltLEXGrVFuxWvviWqtVUYryo1qxarUWFVcUFSKKCgoGVHYIshP27Os87x9nJiTjJJkkMzlzTu7Pdc01kzNnuU8mc+c5z3kWMcaglFJOE2V3AEop1RCavJRSjqTJSynlSJq8lFKOpMlLKeVImryUUo6kyUsp5UgxdhxURNKBm4Gh3hhigU+AB4wx++rYditwOMBbfzDGfBLiUJVSEUrsaKQqIuuAH4FrjTEFItIV+BSrJDjEGFNUy7ZbjTG9miZSpVSksvOycZoxpgDAGLMTeAzoC1xgY0xKKYew5bIRSDPGlPot2+V9btfUwSilnMeWkleAxAXQDzDAkrq2F5FHReRbEdkgIgtFZGzIg1RKRTS7Sl7ViEg0MBF43hizoY7Vc4DvgHsBDzAZeFtEbjXG/KOWY0z2rkt8fPywHj16hCT2SOTxeIiKcueNZDefG7j//DZs2LDfGNMhFPuypcL+Z0GITAcuAs4yxuQ3YPv3gTOAVGNMcV3r9+/f36xfv77ecTpFZmYmGRkZdocRFm4+N3D/+YnICmPM8FDsy/YULyK/AS4Fzm9I4vJaBrQCBoYsMKVURLM1eYnINcAdwDnGmJwg1k8QkaQAb1V4n6NDGZ9SKnLZlrxE5GpgGjDSGLPHu+wX3rop3zodRaRqjJcBjwfY3TCgBFgTxpCVUhHEluQlIlcB/wTmAiNF5GpvMrsI6OJdZwRW84lZfptfISInVtnXZcA44NFGXHYqpRzGrruNM4F4rIap/u7zPucDR4DdVd5b4N3mGRGJBdoCh4Apxpg54QtXKRVpbElexpjkINZZBST7LdsLPOB9KKWaMdvvNiqlVENo8lJKOZImL6WUI2nyUko5kiYvpZQjafJSSjmSJi+llCNp8lJKOZImL6WUI2nyUko5kiYvpZQjafJSSjmSJi+llCNp8lJKOZImL6WUI2nyUko5kiYvpZQjafJSSjmSJi+llCNp8lJKOZImL6WUI2nyUko5kiYvpZQjafJSSjmSJi+llCNp8lJKOZImL6WUI2nyUko5kiYvpZQjafJSSjmSJi+llCPZlrxEJF1E/ikiK0RklYisEZGnRaRDENvGisgDIrJORH4QkS9F5PSmiFspFRnsLHm9BiQDZxpjhgCjgNHAUhFJqGPbmcBlwBnGmEHAv4CPRSQ9nAErpSKH3ZeN04wxBQDGmJ3AY0Bf4IKaNhCR/sBk4BFjzD7vts8BW4CHwh6xUioixNh47DRjTKnfsl3e53a1bDceEGCx3/JFwBQRSTLG5IcoRkfaU+Bh877Av4L2LeNomxgHQF5xGTl5JTXup3f7lkRFCQA7DxdRXFYRcL2kFjF0bB0PQGm5h+2HCmvcZ5c2CSTERQOwP7+EI0VlAdeLjYqiR/vEyp+37MvHAIeLPTXuWzUvtiWvAIkLoB9ggCW1bJoGeIBtfsuzsc5nALA8FDE61fQviyj+/LOA791zwfFcf+YxACxal8Ntr2XVuJ8f7juPpBbWn8jt/81iWfbBgOuNHdKFp684AYAdhwo59/HAxwZ49fpTOLVPewBmZ27muS+yA67XO6Uli/+QUfnzRTO/oKDUSp7Jx+zjzH51Vo0ql7Oz5FWNiEQDE4HnjTEbalk1BSg0xvgXA3K9z+1r2P9krMtNOnToQGZmZuMCjmAp8YZyE7hGYPe2zWRmWnl/S045nRKlxv188fnnxMdY70eVFNe4bsmRnMrf575CT637XPN9FiXbrZLX4ZzSGtdtaYqrfUYp8QYMFJTBO198h2dXXI3HaCjxlBNTnk9MeQEx5fnElhVgBI60GYgnukXIjxdIfn6+q/82Q0mMMXbHAICITAcuAs6q7bJPRBYCpxpjWvktvx6YA1xgjFlQ27H69+9v1q9f3/igI1RmZiYZGRl2hxFysxZv4rGP1jPlrD7cdf5xodlp/j745jlYMRfy9wReJzYR+o6GAb+EfudBXMvQHDsAt352PiKywhgzPBT7ioiSl4j8BrgUyAiivmo/kCgi0X6lL18yOxCOGJ3g6y0H2HagEE+BO+uFWifEAtRYT1Yv+zfCV/+ArFehwlvvJ1EQ3xbi20BCW+t18RHYtRLWzLceMQnQdyScNBl6n9n4OFSD2Z68ROQa4A7gHGNMThCbrAauALoDW6ss7w2UA2tDHaNTvLlyB69/u4PfDAz9JVUkaONNXrnFjUheu1dB5iOw/oOjy/qdD6fdAj1HgAS4jD28Hda+Az/Ohx3LYe27sPY9GP0gnHpz4G1U2NnaVEJErgamASONMXu8y37hrZ/yrdNRRKrG+RZWpX6G3+7OBhYaY/LCG3Xk8pVIEmPd+WVq3zKO9vFSmcTqbeMn8Px5VuKKbgHDfg03fwNXvga9Tq85CbXtbiWpSR/D73+EEVMBAwvvgfemQkUISoKq3mwreYnIVcA/gXuBkXL0D+cMYLd3nRFYdx7nADcCGGPWi8gc4E8i8p4xZr+ITAT6AFc37VlEltyicgBaujR5jTg2hcczEsnIGFz/jX98C964HjxlkHa5VWpKasAdyzbdYNR90DkN5t9k1ZUdzIZLX4SE2lr4qFCz87JxJhCP1TDV333e53zgCN5kVsWtwP/Dao1fBuQBo40xNd/3bwZ8l1OJtlcGRJiVL8G7vwPjgVNuhvMeavyl3qCLoW1PePVyyP4MnhsFV70OyceEJmZVJzvbeSUHsc4qrC5E/svLgD97H8rL7ZeNPsYYJNjk89Us+Ohu6/XZ98CZfwxdHVW34XD9IvjP5ZDzI/zzXLh2PnQeEpr9q1rZ3T1IhVCuL3nFuDN5lVV4uPXTAo7/y4fU2cTHGFj88NHENeYROOvO0Feut+0BEz+0mlIUHbQuTcuKQ3sMFZAmL5fweAylFVYTiQSXXjbGRkdRUgHFZR6KauiqVOmb5+Czv1nNH375DJxyY/gCi28Nl/4b2veF/esh8+HwHUtV0uTlElFRwroHzmfdA2OIjnJnyQuOXhLX2tbr8Db4ZLr1etyzcMJV4Q8sNsE6lkTBlzNh+zfhP2Yzp8nLZeJjo+0OIawSva0kfHdWf8YYeHcqlObD8WNhyOVNF1z3E+E0742B+TdCWVHTHbsZ0uSlHMVXn1djyWvVa7D5U6t1/AV/b8LIvDL+BB2OgwMbYdGDTX/8ZkSTl0us+Okg5z25hOnv/Gh3KGHlu2zMDZS88vbCh3dZr8f8FVp1bMLIvGLjYdwzINHWnc5tXzd9DM2EJi+X2JdXwvq9eew67O5LlZbemxEBuwgt+CMUH4Y+58KQK5o2sKq6DoPTva3w598IpTWPb6YaTpOXS/jqgFo3tOuMQ5zSJYa//GIAad3aVH9jzTuw5m2IS4KLZtjf3/CsaZA6AA5ugU/vtzcWl9Lk5RK+OqDW8e5OXkM6xDDx9N4cm1plRKSiQ/D+HdbrkdOttld2i2lx9PJx2WzYV9sQdaohNHm5hO8yqsGdlp3soz9DQQ70OBWG/9buaI7qcgIMvQYwsPQpu6NxHU1eLlFZ8nJrC1WvA0Ue3vpuB19s3G8tyFkHWS9bo0SMnQlREfYnPeI2q+3X6tfgyA67o3GVCPukVUP57r65veSVfcTD7/+7ihe/2mot8JVohl4DKX3tCqtmycfAwPHgKYcv/2F3NK6iycslTu/bgStP7kHf1FZ1r+xgLas2lTi8Hb5/3apXOu1WmyOrxYip1vPKF6Gg2Q70G3KavFxiwrBuPDx+MIP978K5jK+F/ZGiMmsYZ085DPoVtOtla1y16pwGx46CskKr8l6FhCYv5Si+FvZRRQdhxYvWQl/JJpKdcbv1vHwOlDTbwX5DSpOXSyzbcoDVOw5TXuHOyTd8fC3sLyp+F8qLrKFoOg2yOaog9DwNup9iNaJdMdfuaFxBk5dLXPfCcsb+Yykl5e5OXgkx0FKKuQLv7Han325vQPXhK319NQvKa56pXAVHk5cLlJRXUFzmISZKSIxz96gSUSJc1yKTtlJAedeToOepdocUvL6joeMgyNsNq161OxrH0+TlAlW7BgU9PLJDiaeMP7T6GICYM++wOZp6EoHTf2+9XvoUeOoYUFHVSpOXCzSn1vUd935GVN5uq99g39F2h1N/A8ZZd0YPbrEmsVUNpsnLBY72a3R363o8FfTY9qb1esTUyGtNH4zoGGvAQoBl/2dvLA7nwE9f+cut7Brk8pLXuvdJLNrJkRad+eVnqSxeH8wE6xFoyOUQ1wq2L4O9a+yOxrE0ebnAkeaSvJbPASAz+RJW7SpkzxGHztIT1xLSLrVer3zR3lgcTJOXC4wa0JFFd5zFXWOOszuU8Nm/CbZ+TkVUCzZ2ugioYTRVpxj2a+t51as61n0DafJygcS4GI7pkET35ES7QwmflXMByEk9gxZJ7YA6ZhCKdJ3ToMtQKD5iDaKo6k2Tl4p85SWQ9R8AdnUZTRtvB8eAQ0E7ia/0pS3uG0STlwvMXZrNba99x/Lsg3aHEh7r3oPCA9BxEHmt+lWOFlvj9GdOMehia9jqbV9Z45KpetHk5QLLtx7k7axd7M11aAV2XXwlk2G/BpHKARcdfdkI0CIJBl9ivdaK+3rT5OUCrp5848BmyF4CMQmVX/QeyS25dHg3Mvp3sDm4EKhWce/Sfz5hYmurRhHpDLwAnGeMcXe/ljBydQv7lf+2ngf9ChLaAnBsahKPThhiY1Ah1CUdOg+B3atg7buACxJyE7Gt5CUi44GvgD4N2DZTRNaISJbf49rQRxr5XNvCvrwUsl6xXvtKKG6kFfcNYudl413AKGBpA7e/wBiT7vf4dwjjcwzXjl+//gMo2Gf1Y+x2YuViYwxrd+eybItLhlQeNAFiW8JPX5BQqJN0BMvO5DXCGLPRxuO7gjGG3GKrzquV2+Zs9Kuor+qX/1jKZXO+prjMBSMzxLeGwRcD0GXXxzYH4xy2JS9jjMPvc0eG0goPZ/ZN4dRj2hMX46L7LwezYctiiIk/2pXGS6rccXR0K/uqvJeOnfZ8qgMVBsnJf+23i8hyEVknIktE5Dd2B2SHFjHRvPCbk3h18il2hxJavor6geMhod3P3vbdWXV8cwmfLkOh02Biy/O8FfeqLk6t4T0MbAL+BBQD44GXRWSgMeYPgTYQkcnAZIAOHTqQmZnZRKE2vfz8fEefn3jKOXXZv4gDVkYNIbfKuVSeW6nVHzDzy+XsbOeO0WO7tBpBvz3fc+jTGaw6kGJ3OBHPkcnLGDPOb9E8ETkb+L2IPG2M2RZgmznAHID+/fubjIyM8AfaBIrLKsgvKad1fGzlZWNmZiaOPr8170DZYUjpz9CxU6rVd/nO7YUty9lyZB99jh9ExnEdbQw2hIpPoOLRF2h3+HsyBnWDlGPtjiiiOfmy0d8yrPM5sa4V3WTJhn0Mf/ATbnplhd2hhE4tFfU+vjurju8iVFV8G3JSz7Bea4v7OjkueYlInIgEmlnVd9vJHdcQQfLdaWztljuNh7bC5kUQ3cIatK8Gruki5GdXF+/Q1lmvaMV9HSI+eYlIexGJq7LoNOD1AKsO8z5/F/6oIofrBiJc+RJgYMAvITG5xtWmnNWHj6aeyfihXZsutiaQ16qfNcNQ4QFY977d4US0iE5eItIb2An4D3h0rohcWGW9DOAG4KXm1nbMVUNAV5TBdy9br+toUd+tXSL9O7VyT4nTR0Rb3AfJzu5Bj4lIFjDW+7Ovi0/VUlYRcBDYVWXZSuBO4G4RWSUim4BngAeBiU0TfeRwVdegDR9B/h5o39eaYbq5GnyJ1RE9+zNrliEVkG1/8caYPwaxzh6gi9+yXOAJ76PZc1WnbF8ldS0V9T5rduXy/BfZHJuaxI0Z9e4eG9kS2lrt21b9x2rvNnK63RFFpIi+bFR1c81wOIe3w8aPIToOhlxR5+oHC0p5Y+UOPt+4rwmCs4Hv0vG7l60O6upnNHk53O/OPZZnrhpKeve2dofSON95K+qPHwst29e5ulvvNlbqfhJ0ON7qmL5hgd3RRCRNXg6X1q0tFwzuTMfW8XaH0nAV5d67jMCw64LapLKdl9PHsa+JVtzXSZOXst+mjyFvFyQfA73OCGoT14xjX5u0S62O6ZsXWe3fVDWavBzuiYXreTZzM2UVHrtDabggWtT7a+W9u5pbXIbHY8ITl90Sk2GAtyfcymY5VF2tNHk5WFmFh6cXbeKxj9YRHeSXPuIc2QEbF0JULAy5MujNYqKjSGoRgzGQX+ri0lfVS8fSQjsjiTiavBwsr/joncaoKIcmr+9eBuOB438BSfUbv/2k3smcfmwKZeUOLnXWpccp1nA5hQeONuBVgCYvRzvaQNWhzSTKiuCb563XDRij/l+/PpGXJ51M+6QWoY0rkojAGbdbr7+cafVCUIAmL0dz/Nj1Wa9AQQ50SoPeZ9kdTeTqf6HV6+DINvjhDbujiRiavBzsaKdsB3YNqiiHpU9br0//fdAV9VV5PIYjhWUUlbpgHPvaREXB6VOt11/MAI+LL5PrQZOXg/naODnysvHHt+DwT5DcxxpBogHufGM1Q+5fyLurdtW9stMNvhRadYF9a2HjR3ZHExFCmrxE5JlQ7k/VThA6t4l3XgNVY+CLJ63XI26DqIYNwVbZ1sutDVWriomD026xXn/+hPU7bObqdb0RxKSuFzQiFlVPF6Z15sK0znaHUX8bPoKcH6FV51oHHKyL67sI+Rt6HXz2KOxYDtu+at4jb1D/USXm1vKe/itQdTMGvvAOCHLqLRDT8DuFR1vZN5Pk1SIJTr4BPvubVXJt5smrvpeNa4Hefo9BwATgLWBkSKNT7rPtK9i+DOLbBt2PsSZH+ze6uJGqv5NusMb62rgQ9vxgdzS2qm/y+p0x5ie/xxpjzJvANcDUMMSoanD761kMf/ATPlmz1+5Qgve5t9R18g3QolWjduW6uRuD0bL90aS/dIa9sdisXsnLGPNpLe8VAcc1OiIVtP35pezPLyE62iGt63evtjphxybCyVMavbujMwg1o+QF1uV2VIzV5qsZj7Ra3wr7MwMtBtoB47AmgFVNxHEt7H13GIf9utbJNYJ1bGoST12eTuc2CY3el6O07Q5pl1mNfD+4E676X4PayTldfSvsMwlcMS/ADuDqxgakgpfnpBb2+zfCmvlWB+xTbwnJLpNbxvHLdHfNHhS0c/8C696zSrKrX4chl9kdUZOrb/LaDEzyW1YB5ACbjTEub+ocWRzTwt7jgXdutTpgn3ANtGmmCSeUWnWC8x6Gt2+GD6dBn3Pq3bHd6er7Vz/LGPNZWCJR9WKMcU4L+2WzrbuMSR1DPpnEC0uzOVRQyi3n9CUuppl1GEm/Cr6fB1sWw4I74ZIX7I6oSdW3wr55396IIEVlFZRVGFrERBEfG8GThB/YDJ/eb72+6KmQ1HVVNXPRJp5etKl53XH0EbF+p7Et4cc3m90ktc3sX5V7RInw5wuPZ+rIfnaHUjNPBcy/CcqLIO1y6H9+yA/h+rHs69Kup1X/BfDe7VB02N54mpAmL4eKj41m0hnHRPachctmw/avIakTnP9IWA7hm2y32TWXqOqk66HbSdaEvR/fa3c0TUaTlwqP/ZuqXy4mtAvLYZplQ1V/UdHwy39Yc16u/DdsybQ7oiahycuhth8s5O2snazeEYGXCZ4KePsmKC+2JpDtPyZsh2rdHLsIBdKhP5x1p/V6/k1WXaPLafJyqG9/Oshtr2Xx/BfZdofyc1/NsvovtuoMY/4a1kP57rQ265KXz4ip0P0UyN0JL1wAOWvtjiisNHk51JHCCGwmYYw1Oqqv3iWMl4s+KUlxpCTF0fzalwcQHQtXz7PmvszfAy+cDztX2h1V2GjycijfZVLEtK73VMAHfzyauEY9AP3OC/th7xjdn2//PIqrT+kZ9mM5QotWVnehvudB0SF4cSz89KXdUYWFJi+HiqjW9aUF8NpV8M0/rUrjCf+CEb+zO6rmKzYBLnsZBo6H0jx46Vew6RO7owo5W5OXiHQWkQ9FRAcyrKfcSOmUnbcX5l4IGxZYY3Rd+zYMutjemJQ1bPTFz8MJV1vt7P5zOSz5O5Tk2R1ZyNiWvERkPPAV0KCGSiIyVUTWiMhqEVkpIuNCG2Fk8zXKtO2ysaIc1r4Lz4+EXd9B254w6ZMmH93z260HOfWvn3L9v79t0uM6QlQ0XDQTTrkJPGWw6AGYMRiWPAbFuXZH12h2lrzuAkYBS+u7oYjcBfwZuMgYkwZMA/4nIqFvwh2hcouOzpbdpPL2WOOozxgM/70aDm+DrsNg0qeQ0rdpYwGio4TdR4rZm6ujMQUUFWXd8b1mPvQ41aoHW/QgzBgEmX9zdIt8OytMRhhjyqWe4xCJSFvgXuBxY8xmAGPMxyKyEPg7sCDkkUaglyedTH5xOfFxYf7/46mwpijLWQvf/88qbXm8baqS+8CJv4XhE616Fhs02wEJ66vP2XBMBmQvscbA/2kpZD5slcI6p1kt9LsNh+4nQZvujhgfzLbkZYxpaKvCMUAisNhv+SLg7yJynDFmXW078JSXkP3jsoDvdWqTQIK3o/OB/JIa+8zFREfRvV1i5c/Z+wuoaQ6S5JYtKr9kecXl7M+vuZTQM7klUVHWH86uw0WUlAceZahli1hSWwWYvMIYWuZv9Y5vbqotx1RYw9IYYyUl47HqQ0oLrUr3sgLrddFBa/yt/Rvh4GaoKD26H4mC434BJ06yZrmOsveej6/keaiwjHV7cklqEUM37+dSWu5hy/78Grft1i6RpBbWVyAnr5iDBaUB14uJiuLY1KTKnzfuzaOihqnHUpJakJJkfS65xWXsOlxU4/GP7ZBETLT1+9t+sJCC0nK253lYt6f6JV1IzynxBDj/NVrt/pquq2dC9uewc4X18H4lyhNTKW3Vg4qEZCri2xPXJpXEth0hoR2FJoaDxWCi4jDR3kdUDCAgQrfkJGKiowFhT24JRWXev98wJMMIuFVVb2neZ//WmdlV3q81ebUp2k7v/42u80DtvY9g9A5yvVbeRzC6BLmevxMBQlkF1LqrdUnY/RQYem1EjcfVpkr3oDEzPmfMwE7MvmYYAHtzixkz4/Mat/33xJM4s581BtbcpVt5JjNwq/SubRNYetc5lT9f8n9fcbgw8D+1P57Xn5vPPhaApRv3c+MrNbez+u7eUbRrGQfA3W99z+cb91tvLK0ec/jO6V0oPgI7VzDr5dcYUL6OE6I20bYwh5jCnIDbJXofwegU5HoN5cTkleJ99r9t4vt3FTDfiMhkYDLAoM7xbKZ7wJ0nxwux3jHh80o91PA3SkwUtE84WurIKfDUOPdbqzghMdbaZ1G5Ibek5purHROl8r/UwSIPZTXM7J4QA61bBC71eDweoipLREf/4xmJwkgUIJXPnqg4KqLjqzxaUBHdksLEzhQmdqMooQsVMVX+XL/bCGysMf5wy8/PJzMzs9qyMb1i+WG/VZD35O+vfP9QsYduSTX/x1//42o8u6xS9uE9ZTWu2za6tNoxO8RVkBQVeN19O7LJzNwBwOb9FbUe/8svl9LS+3cRVVRCtyShwuMh2q80G/5zimJ+i/G8Gm3AGLqQQwcO0tbk0pZchrUpoF9iPrFl+eQWl7Enr4RYyomljFhTTjQeBINg6NISosQgxnCw2FBaYfBdAViR/Fhj7PVmjLH1gTUXpKnH+nO8v432fstHeZffWNc++vXrZ9xs8eLFdocQNm4+N2Pcf37AtyZEucOJjVS9ZeufXX35fj7QhLEopWzixOS12vvcy295b7/3lVIuFvHJS0Tai0hclUUfAoVAht+qZwNrTB13GpVS7hDRyUtEegM7gbd9y4wxh4EHgJtF5BjveiOB84A/2BGnUqrp2Xa3UUQew6pk7+H9Ocv71knGGF/jlCLgILCr6rbGmEdEpBh4T0TKsaZfu8QY0ywaqCql7G2k+scg1tlDDc2djDWTkc5mpFQzFdGXjUopVRNNXkopR9LkpZRyJE1eSilH0uSllHIkTV5KKUfS5KWUciRNXkopR9LkpZRyJE1eSilH0uSllHIkTV5KKUfS5KWUciRNXkopR9LkpZRyJE1eSilHcuK8jU0iNzeXnJwcysqcN418mzZtWLt2rd1hhEVDzi02NpbU1FRat24dpqiUHTR5BZCbm8vevXvp2rUrCQkJSBimKg+nvLw8WrUKdl5uZ6nvuRljKCoqYufOnQCawFxELxsDyMnJoWvXriQmJjoucanqRITExES6du1KTk7gKeyVM2nyCqCsrIyEhAS7w1AhlJCQ4MgqAFUzTV410BKXu+jn6T6avJRSjqTJSynlSJq8VMSYPXs2AwYMQESYO3eu3eGoCKfJqxnIyckhPT2d5ORkRIT09HSee+65eu1j2rRpDB8+vNqyrKwspk+fzuHDh6stLykpoXfv3jz11FP1OsaUKVP44IMP6rWNar40eTUDqampZGVlMXbsWMBKOpMmTar3Pnr06FFtWVZWFvfdd9/PkldMTAw9evSgffv2jQtcqVpoI1UVlDvuuIM77rgjqHWjo6P57LPPwhyRau605NWM+S4le/XqxYIFCzjnnHPo1q0bo0aNYseOHZXr3XzzzfTo0QMRYevWrQDcc889/OUvfwHgggsuID09nQkTJnDgwAHS09NJSkoiIyOjch/FxcXcddddDBs2jKFDh5KWlsaUKVN+VmpTKliavJox36XkoUOH+Oqrr1i0aBHr1q1j27Zt3HnnnZXrzZo1i/vvv7/atg899FDlsg8++ICsrCzmzZtH+/btycrK+ln92OHDh3nhhReYP38+K1euZPny5Rw8eJBrr702/CeqXEkvG+uh113v1/jew+MHc+XJVp3Qf5Zt4+63vq9x3a2PXFj5+hczP+eHnbkB17vipO789VdpAHy/4wiDu7VpSNh1ysvLY+rUqQAkJSUxatQo3nzlhdsCAAAPhUlEQVTzzZAeIyUlhS+//JLu3bsDEB8fz8SJEzn//PPZu3cvHTt2DOnxlPvZlrxEJBV4EvD9i/4emGqM2VHzVpXbbgUCXW/8wRjzSciCbCZSUlJITk6u/Dk5OZm9e/eG9BgxMTFs2LCBm266iZ07dxITE0N+fj4AW7Zs0eSl6s2W5CUiccDHwAZgIGCAfwGLReQEY0x+XfswxqSHN8qfq1piqs2VJ/eoLIXV5b1bzwhqvXCVugASExOr/RwVFYXH4wnpMRYsWMCFF17IE088wW233YaIkJmZydlnn01JSUlIj6WaB7vqvK4D0oBpxphyY0wFMA04BrjRpphUGL300kskJSUxdepU7WeoQsKu5HUxsM0Ys8W3wBizB1jjfU85QGxsLGCNmQXw0UcfcfDgwYDrlpSUEBVV/c9tz5494Q1QuZpdySsNyA6wPBsYHMwORORREflWRDaIyEIRGRvSCFWdevfuDcCOHTvIy8tj/Pjx5OXlBVz3wgsv5MiRI5Ut+/Py8pgxY0aTxarcx64K+xRgRYDluUCiiCQYY4pq2T4H+A64F/AAk4G3ReRWY8w/Am0gIpO969GhQwcyMzNr3HmbNm1q/BI6QUVFRbX49+3bx7hx49i+fTsAaWlpTJ48mddff53vv/+egoIC0tLSeOedd3jkkUd46623Ktd74okn+O9//8uHH34IwJgxY7jlllu47rrrGDx4MNdeey1XX301CQkJTJ06FWMMaWlpbNmypXIf8+fPZ8KECWRnZ3Pffffx5JNP0qlTJzIyMli2bBkTJ05kypQpxMXFMXv2bADuvfdePv/8858lOP9zq4/i4uJaP/dIkJ+fH/ExRgrxFfmb9KAipcBHxpiL/Ja/AlwJJNaRvALt833gDCDVGFNc27r9+/c369evr/H9tWvXcvzxx9fn8BFFh4EOzAmfa2ZmZrXGvW4jIiuMMcPrXrNudl027gcC/QW2Agrrm7i8lnm3H9iYwJRSzmBX8loN9AqwvDdWe68aiUiCiCQFeKvC+xzduNCUUk5gV/J6E+gpIr18C0SkI3A88EbVFUWko4hUjfMy4PEA+xwGlGDdsVRKuZxdyWsuVgnrbyIS401Oj2DdbXzWt5KIjAB2AbP8tr9CRE6sst5lwDjg0WAauCqlnM+Wu43GmFIRGYXVPWgNVgv7H4Bz/JJPPnAE2F1l2QLgMeAZEYkF2gKHgCnGmDlNEb9Syn629W00xuzFurNY2zqrgGS/ZXuBB7wPpVQzpUPiKKUcSZOXUsqRNHkppRxJk5dSypE0eSmlHEmTl1LKkTR5qWpmzJjB/Pnzm/SYZWVlvPrqq4wePZphw4YxcOBAhg8fzosvvoj/wAGvvPIKnTp1Ij09vdpjwoQJTRqzsp9OwKGqmTFjBhkZGYwbN67JjrlixQquuuoqXnnlFa644goA5s2bxyWXXMKmTZt44IHqTfqmTJnC9OnTmyw+FZm05KUiwmmnnVaZuAAmTJjA6aefzlNPPfWz0pdSoMnL9d555x3S09MREe69916mTZvGsGHD6NatG/fcc0/letu3byc9PZ1du3ZVbpOens4nn4R/MqaTTz6ZxYsX/2x5ly5dKCgooKysLOwxKOfRy0aXGzt2LGPHjkVEeOmll3jjjTf429/+xsKFCznvvPM466yzGD16NN27dycrK4tevXqRkZHB3Llz69z3t99+y6RJk+pcb/jw4ZXDPwciIpXj4Ve1YcMGTj31VOLi4qotX758OWPGjGHnzp0AjBw5knvuuYeUlJQ6Y1HuockrWNPDN/VYvUw/0uBN09PTGTZsGACjR48mKSmJzMxMRo8e3aD9DR8+nKysrAbHU5vly5ezevXqn5XIWrRoQUxMDDNnzqRnz55s3ryZSy+9lPfee49vvvmGtm3bhiUeFXn0srEZ6devX7Wf27VrF/LJZUMhPz+f3/72tzz44IOceeaZ1d6bMGEC77zzDj179gSgT58+zJ49m02bNjFrlv/IScrNtOQVrEaUeCJFoMllKyoqaljbHqWlpVx88cWMHj2aP/3pT0FtM2zYMGJjY/n666/DHJ2KJJq8VIOFqs7Lp7S0lF/96lcMGDCAxx8PNFgu7N+/P+AEHCIScYlYhZcmL1VNbGxsZdOEn376iZ07d3LaaacFXDeUdV6+Elffvn158sknK5ffcMMNTJ8+nc6dOwOQkZHB119/XfkzwA8//EBpaSlDhw4NSSzKGTR5qWp69+7Njh07AJgzZw67d++uMXmFSmlpKRMmTGDLli1cdtllvPzyy5XvLVmyhJKSkmrr33333Tz77LPEx8dz4MABbrnlFlJTU7n55pvDGqeKMMaYZvfo16+fqc2aNWtqfT/S5ebmVr5esmSJGTJkiAFMx44dzU033WQOHTpkhgwZYmJjY027du3MueeeW7n+0qVLzXHHHWcGDRpkTj75ZLN+/fqwx/v2228brKHAAz6ys7Mr1503b5655JJLzKBBg8zAgQNNt27dzJVXXmm2bNlS53Gc8LkuXrzY7hDCCvjWhOh7bMuks3bTSWedSyeddTY3TDqrlFKNoslLKeVImryUUo6kyUsp5UiavJRSjqTJSynlSJq8atAcm5C4mX6e7qPJK4DY2FiKiorsDkOFUFFRUcAxw5RzafIKIDU1lZ07d1JYWKj/sR3OGENhYSE7d+4kNTXV7nBUCGnfxgBat24NwK5duxw5BHFxcTHx8fF2hxEWDTm32NhYOnbsWPm5KnfQ5FWD1q1bO/aPPTMzkxNOOMHuMMLCzeem6kcvG5VSjmRb8hKRVBF5RUTWex/zRKRbkNvGisgDIrJORH4QkS9F5PRwx6yUihy2JC8RiQM+BuKAgcAAoABYLCJJQexiJnAZcIYxZhDwL+BjEUkPU8hKqQhjV8nrOiANmGaMKTfGVADTgGOAG2vbUET6A5OBR4wx+wCMMc8BW4CHwhq1Uipi2JW8Lga2GWO2+BYYY/YAa7zv1WY8IID/LKWLgNFBltyUUg5nV/JKA7IDLM8GBgexrQfYFmDbGKxLUKWUy9nVVCIFWBFgeS6QKCIJxpiamrinAIXeS03/bQHaB9pIRCZjXW4ClIjID/WM2UlSgP12BxEmbj43cP/59Q/VjiKtnZeEa1tjzBxgDoCIfBuqoWgjkZvPz83nBs3j/EK1L7suG/cDgQYib4VVqqqtY+F+rNJZdIBtAQ6EID6lVISzK3mtBnoFWN4b+D6IbaOA7gG2LQfWNjY4pVTksyt5vQn0FJFevgUi0hE4Hnij6ooi0lFEqsb5FtaUWBl++zwbWGiMyQvi+HPqH7KjuPn83HxuoOcXNFumPvM2Uv0Wq5R0Fdbdw+eB04ETjDH53vVGAEuAOcaYG6tsPxsrWY0wxuwXkYnALOBUY0xopnBWSkU0W0pexphSYBRQgdW2ay3QGjjHl7i88oEjwG6/XdwK/A9Y6r1reD0wWhOXUs1Hs5x0VkUmEekMvACcZ4xpzJ3niOPmc7OLa0aVcHtH70ae31YRyQrwGBnuuIMlIuOBr4A+Ddx+qoisEZHVIrJSRMaFNsKGa8y5iUim97z8P7trQx9p/YlIuoj8U0RWiMgqb6xPi0iHILZt3PfOGOP4B1YH71VYl5IxQDTwIrARSApi+9nABqCD9+dJQBGQbve5hej8ttp9DkHEuAzoC8y1/izrte1dWE1o+nh/HgWUAefbfV4hOLdMoJfd51BLfOuwbrK19P7c1btsA5BQx7aN+t7ZfvIh+gVej3UH8pgqyzph1an9sY5t+2PdMJjot/xH4H27z62x5+ddd6vd5xBEjDHe53p9wYG2WCOS3O+3/H3gR7vPqzHn5t3GCcnrWL9lv/X+vV5cy3aN/t655bLR7R29G3N+jmCMKW/gpmOARAJ/fgNE5LhGBRYCjTg3J0gzxmzyW7bL+9yulu0a/b1zS/Jye0fvxpwfACLyqIh8KyIbRGShiIwNaYT2SfM++/9+sv3ed7LbRWS5t25oiYj8xu6AfIzVcsBfP6yS15JaNm30984tySsFCNQ4tbKjdx3b1rujdxNrzPkB5ADfASOwBn98G3hbRG4JaZT2SPE++/9+Iunza4zDwCasdo0DgaeBZ0Xk77ZGVQNvt72JwPPGmA21rNro712kdcwOtbB19I4QQcVojDnJb9EsEbkAeFhEnjPGFIc+NNs54fOrkzHG/67pPBE5G/i9iDxtjPEvudjtXqxuer9v4PZBf25uKXm5vaN3Y86vJsu82w9sTGARwDd8jP/vJ5I+v1BbhvXdPdHuQKryXs5einWXN7+O1Rv9vXNL8nJ7R+8Gn5+IJNRQ+ekrrvv/8TjNau9zL7/lvf3edxwRiRORNgHeirjPTkSuAe7A6iWTE8Qmjf7euSV52d3RO9wac36XAY8H2OcwoATrjqVjiEh7b99Ynw+BQgJ/fmuMMeuaKrbGCnBupwGvB1h1mPf5u/BHVTcRuRprDoqR3rvgiMgvvAOA+tYJ/ffO7nYiIWprEoeVyf+LVY8XhdUVo1ojTqwK6wrgWb/tZwPrgRTvzxOJvEaqDTo/4NdYlaAnVll2Gdadnvub6hzqca5zqaEtFNZ/5WJggd/yu4B9eNvBASOJoEaqDT037xe7HLjQb1kB8G+7z8cbz1Xe78ofgKurPP4PmG5q+Lv0Lm/U984VFfbGmFIRGQU8iVWSMMAP1K+j9//D6uhdhnXnKmI6ejfy/BYAjwHPiEgsVqPOQ8AUY40uGxFE5DGslvE9vD/7fvcnmaO344uAgxxtRwSAMeYRESkG3hORcqwvyiXGmAVNEnwdGnFuK4E7gbtF5GGgJVAKPIj1mUaCmUA8geO5z/sclu+ddsxWSjmSW+q8lFLNjCYvpZQjafJSSjmSJi+llCNp8lJKOZImL6WUI2nyUko5kiYvpZQjafJSSjmSJi+llCNp8lJKOZImLxXRvHNV5oqIR0Q+8S6bJSKHRCRbRCbZHaOyh3bMVhFPRC7BGtfqemPMcyLSE3gXOM3UPWKncilNXsoRRORNrHG60oF/AQ8bYxbaG5WykyYv5Qgi0glrLLMK4D1jTMRM/6XsoXVeyhGMNbzwfVhTZvlPVKqaIS15KUfwjn+eCSRgjUg60Bizv9aNlKtpyUs5xW1YU36Nwxp2+Cl7w1F205KXingi0geYh3V3sUhEbsCavOEiY8x79kan7KIlLxXRROQh4AugE9bsMgA3eZ9fEZF5tgSmbKclL6WUI2nJSynlSJq8lFKOpMlLKeVImryUUo6kyUsp5UiavJRSjqTJSynlSJq8lFKOpMlLKeVImryUUo70/wFVOXM5uoLJ3AAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the solution after nt time steps\n", + "# along with the initial conditions.\n", + "pyplot.figure(figsize=(4.0, 4.0))\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('u')\n", + "pyplot.grid()\n", + "pyplot.plot(x, u0, label='Initial',\n", + " color='C0', linestyle='--', linewidth=2)\n", + "pyplot.plot(x, u, label='nt = {}'.format(nt),\n", + " color='C1', linestyle='-', linewidth=2)\n", + "pyplot.legend()\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 2.5);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's funny. Our square wave has definitely moved to the right, but it's no longer in the shape of a top-hat. **What's going on?**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Dig deeper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The solution differs from the expected square wave because the discretized equation is an approximation of the continuous differential equation that we want to solve. There are errors: we knew that. But the modified shape of the initial wave is something curious. Maybe it can be improved by making the grid spacing finer. Why don't you try it? Does it help?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Spatial truncation error" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recall the finite-difference approximation we are using for the spatial derivative:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial u}{\\partial x}\\approx \\frac{u(x+\\Delta x)-u(x)}{\\Delta x}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We obtain it by using the definition of the derivative at a point, and simply removing the limit, in the assumption that $\\Delta x$ is very small. But we already learned with Euler's method that this introduces an error, called the *truncation error*.\n", + "\n", + "Using a Taylor series expansion for the spatial terms now, we see that the backward-difference scheme produces a first-order method, in space." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial u}{\\partial x}(x_i) = \\frac{u(x_i)-u(x_{i-1})}{\\Delta x} + \\frac{\\Delta x}{2} \\frac{\\partial^2 u}{\\partial x^2}(x_i) - \\frac{\\Delta x^2}{6} \\frac{\\partial^3 u}{\\partial x^3}(x_i)+ \\cdots\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The dominant term that is neglected in the finite-difference approximation is of $\\mathcal{O}(\\Delta x)$. We also see that the approximation *converges* to the exact derivative as $\\Delta x \\rightarrow 0$. That's good news!\n", + "\n", + "In summary, the chosen \"forward-time/backward space\" difference scheme is first-order in both space and time: the truncation errors are $\\mathcal{O}(\\Delta t, \\Delta x)$. We'll come back to this!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Non-linear convection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's move on to the non-linear convection equation, using the same methods as before. The 1-D convection equation is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial u}{\\partial t} + u \\frac{\\partial u}{\\partial x} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The only difference with the linear case is that we've replaced the constant wave speed $c$ by the variable speed $u$. The equation is non-linear because now we have a product of the solution and one of its derivatives: the product $u\\,\\partial u/\\partial x$. This changes everything!\n", + "\n", + "We're going to use the same discretization as for linear convection: forward difference in time and backward difference in space. Here is the discretized equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{u_i^{n+1}-u_i^n}{\\Delta t} + u_i^n \\frac{u_i^n-u_{i-1}^n}{\\Delta x} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Solving for the only unknown term, $u_i^{n+1}$, gives an equation that can be used to advance in time:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u_i^{n+1} = u_i^n - u_i^n \\frac{\\Delta t}{\\Delta x} (u_i^n - u_{i-1}^n)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "There is very little that needs to change from the code written so far. In fact, we'll even use the same square-wave initial condition. But let's re-initialize the variable `u` with the initial values, and re-enter the numerical parameters here, for convenience (we no longer need $c$, though)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "nx = 41 # number of spatial discrete points\n", + "L = 2.0 # length of the 1D domain\n", + "dx = L / (nx - 1) # spatial grid size\n", + "nt = 10 # number of time steps\n", + "dt = 0.02 # time-step size\n", + "\n", + "x = numpy.linspace(0.0, L, num=nx)\n", + "u0 = numpy.ones(nx)\n", + "mask = numpy.where(numpy.logical_and(x >= 0.5, x <= 1.0))\n", + "u0[mask] = 2.0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " How does it look?" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS8AAAEoCAYAAAAJ23dgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XmcXFWd9/HPt9Pd2TphScIakbAkIhrQKI+KOmEJAm7gAuMAjjLAyLgiKKKjwqDowDA6IMggCDr6DM4AjiMzOKCkBYIDD2vEEMKSgBBCEkKWTrrTne7f88e9lRRldXrvW/fW9/161au6zj3n1u/U8ut7zz33liICM7O8acg6ADOzwXDyMrNccvIys1xy8jKzXHLyMrNccvIys1xy8holkhZKWiUpJHVKWiHpK0Nc568l/UHS2AG2u1bSc5J2HeTzfjSNv1NSYebapH1al75HH6tYdlS67OMDXOfrJa2W9PVhDdacvEZLRMwG3pw+vCcidouIbw5xtVOBHYEx5YWSzk+/gHN7aTcFmAw0D+ZJI+LHEbEbcM9g2teqtE+f7WVxCzAJ2KFyQfpat/bSbnzabqfhiNG2acw6ABuSOUBDRHQNsN3xQHNEbB6BmAopIm6WNCEiOgbY7j5JOwy0nfXNySvHIqIb6B5EuwCcuAZosAnIiWtkeLexBkj6XjreEpJaJb0pvV8l6RlJl0oaV1Z/Vlq/rXz3UNIYSSuAc9KqN6f1Vkj6iqQJfYzrvEvSv0p6StKLkl6S9F+SDhnGvh4p6TZJK9NYFku6XtKRFfUk6ROSHkjrrpR0t6QPV9Q7N11Pt6RlkvaTdEta9oKk6yTtWCWORklfT9uskfSYpC8AqlL3B+XvT+Vzpw/fVvZar5A0VtLXymOrst5mSeel45Yvpn28TdLhFfUG9Pkoa3eSpHslLZf0vKSHJF0saeb236WciAjfRukG7A0E0NrL8gCeAn4K7EzyRTotLf/7KvXPT5fN7U952fKPpcs/VlHeCtwN7Jk+ngbcBHQAb6yynlbSDbl+9v8MoAe4GBiflh0MPAmsraj7I6AT+PP0dWgEPpfGfUGVdS8DVgM3AtPTsmNItkx/VqX+T9JYTif5Jz4eOA94tNprU/b+/Ml7t733tCy2ZRVlTcCvgbXAEWnZeOCSNK6/GsrnAzgpXc8HysoOA9YB52f9XRiW71PWAdTTrZ/JqxPYraJ8OfB0lfrDnbz+GZhTUTYZ2ALcUGU9/U5ewJ5pEnwCUMWy95UnL+ADaXw/rLKe+emXsjLOZWmbyvJ7SHaRm8rKDkvr/neV9f92lJLX59N2X6soF0ky7wD2GOznA7gZeKlKLBcAn8n6uzAcN+821p6nI2JFRdkzwPSRfuKI+OuIeKCibD3Jl2P2EFf/YWAs8B+RfovK/A/wwbLHp6T3N1dZz00kX/CTqizrqIyf5LVrJtmKLCk91y+rrOPXVcpGQtU+pq/Nf5C8Vh+q0q6/n48XgZ0lXSlp67KI+HpEXDakyGuEk1ftWVmlbDPJbsaIkvQqSd+R9Ej5+A3JVtOEIa6+NM7yfOWCiNgcEb8pK5qV3j9XZT2l9q+psmxVlbLSgYnyaSH7pffLq9SvVjYSBtvH/n4+vgbcDpwJPJuOfZ0naffBBFuLnLxqT08WT5p+qB8ETgD+hmTca7dI5j79cTieYpjrVpscO9DXbiAxZWHQfYyIVRFxFPB64Bsk88wuAp6Q9L7hCzE7Tl5WcgLJpNfLI2JBJNMwhtPi9H7PygXpUdLpkpr7qltW9vgQYnkyvd+jyrJqZSOhFP+I9DF9TRURj0bE1yJiJsn8vibg8sGut5Y4eRVTW3rfBCDpNZIu7qNNaS7SK/6zKzn1aLdhiOnfSXZvjpNUucXzIWAJydE2SI4EQvJlq1Qq+79DiKU0zvT+KsvmDWJ9GynbbZP0ucrpDlVU7WP62ryf5LW6cRCxlPyG5B/SVhHxHyRHUwsx29/Jq5h+n94flN5/FDiijzb/TXLY/jOS3gAgaRJwFcng8ZBExHLgM8C+wLdK85LSOWSXAhdFxLq07k0k0wFOkXRCOuerUdKngcOBb0bE/UOI5Q7gBmCepDMkNUgaJ+k8YP9BrPL3wH6SJio5X/TrwMQ+2lxGcrT27FKiS1+Tb5G8Rp9JX7Oh+LKk0tgakt4DvA74lyGutzZkfbizXm7AQpIB5dLh7hXAV9JlX0sfly97W3pbkZZFqQ3JYO8Kki2sANYA/6/i+S4lGXxeAdwHvIlk0H0FyVyfSO9XlLV5I3AryXyp1cAjJNMqniGZL7WCJBF+tEpc/9TP1+FIkoHkVWm7h4DTqtQTyWDzgySD1KuABcCJFfU+nq6nuyzGE4FXpX+3pzGuAq4qa9dEMqXkmfT1exL4JslctK2vDUni/kGV9+fEsnXNSV/j1STjg5em8Zfe1/LYzilrNxb4MrCorI+3A/Mq+jigz0fa5u1p3I+ln4MXgAeATwFjsv4+DMdNaUfNzHIlk3MbJR0MfJLkP30j22YbXxgR1Q53l7ddRrJ7U+mciBitOTpmlrFMtrwkLQb+AHw0IjZK2pNkgLEBOCgi2rfTdllE7D06kZpZrcpywP7ciNgIEBHPk5zTtT9wbIYxmVlOZHVJnNkR0VlRVjqyUojDuGY2sjJJXlUSFySnjwRwZ1/t0zlLh5OcNLwM+F5E/Gcfbc4gOZLEuHHj5uy1114DjDo/enp6aGgo5iyYIvcNit+/JUuWrI6IaX3X7IesD3emY25jSA7L/6Afde8DPkJymLmJZOA/gE/19/lmzpwZRTZ//vysQxgxRe5bRPH7B9wfw5Q3auVKql8luezKWX1VjIjKC+NdIelY4CJJ14SvWmlWFzLfPlXyaywnAMdERFtf9XtxL8mPHBw4bIGZWU3LNHlJOgU4Gzg8Iqpd6qOy/nhJLVUWlU4iHlNlmZkVUGbJS9LJwLnAkZFeXE3Se9KB9VKdXSWVx3giyakXleaQnMi6aARDNrMakknyknQSyXlX1wNHSjo5TWbvJb0kiaRDSaZPXFHR/COS3ly2rhOB44CLh7DbaWY5k9WA/eXAOJKJqZUuSO/bSE6OfaFs2a1pmyslNZH84OrLwCci4uqRC9fMak1W87x27kedR0h+IaW87EXgwvRmZnUs86ONZmaD4eRlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmuZRZ8pJ0sKQfSHpA0iOSFkm6TNK0frRtknShpMWSHpV0j6S3j0bcZlYbstzyugHYGXhnRBwEzAOOAhZIGt9H28uBE4F3RMTrgB8Ct0s6eCQDNrPakfVu47kRsREgIp4HLgH2B47trYGkWcAZwLcjYlXa9hrgaeCbIx6xmdWExgyfe3ZEdFaULU/vd9pOu+MBAfMryu8APiGpJSLahinGXFqxsYenVlV/CaZMbGbHCc0AbOjoYuWGzb2uZ8aUiTQ0CIDn17bT0dVdtV7L2EZ2nTwOgM4tPfzx5U29rnOPHcYzvnkMAKvbNrOuvatqvaaGBvaaMmHr46dXtRHA2o6eXtdt9SWz5FUlcQHMBAK4cztNZwM9wLMV5UtJ+vNa4L7hiDGvzr+nnY67flt12VeOPYDT37kPAHcsXslnb3i41/U8esG7aBmbfEQ+/7OHuXfpmqr13nfQHlz2kTcA8NzLmzji0urPDfCvp7+Ft+47BYCrWp/imruXVq03Y+pE5p8zd+vj915+Nxs7k+S58z6reOfMPodGreCy3PJ6BUljgFOBayNiyXaqTgU2RUTlZsD69H5KL+s/g2R3k2nTptHa2jq0gGvY1HHBlqg+IvDCs0/R2prk/adXbmG3Cep1PXffdRfjGpPlDZs7eq27ed3Kra/nqk09213not8/zOY/Jltea1d29lp3YnS84j2aOi4gYGMX/OfdD9GzvLnX58iztra2Qn82h1VE1MQNOB94AGjpo95twIYq5aeTbLUd09dzzZw5M4ps/vz5WYcwIr53xxPx6nNviW/992NZhzJiivrelQD3xzDljJrY8pL0ceAEYG70PV61GpggaUy8cutrUnr/0kjEmAf/+/RLPPvSJno2FnNcaPL4JoBex8msvmR9tBFJpwBnA4dHxMp+NFlIEverKspnAFuAx4Y3wvy4+cHn+OJNC3l8TfWB9bzbIU1e6zucvCzj5CXpZOBc4MiIWJGWvScdnyrV2VVSeZw/J9k9nFuxusOA2yJiw8hGXbtKWyQTmnofc8qzKRObmTJOW5OY1bfMdhslnQT8APgqcKS09Qv3DuCFtM6hJEcerwbOBIiIxyVdDZwn6ZaIWC3pVGBf4OTR7UVtWd++BYCJBU1eh+43lUvnTmDu3NdnHYrVgCzHvC4HxpFMTK10QXrfBqwjTWZlPg18nWQ2fhewATgqIno/7l8HSrtTE2piJNNsZGU5z2vnftR5hOQUosryLuBv05ulir7bWBIRlG2pW53KfMDehs/6UvJqLOYXu6u7h0//ZiMHfO1XpekxVsecvAqipyfo7E6mSIwv6G5j05gGNndDR1cP7b2cqmT1o6Af8/rT0CAWX3gMHV3d/O+Cu7IOZ8RMaBKdm4N17V1MaPbHt555y6tgxjWNyTqEETUhnSVROrJq9cvJy3KlNJ7nWfbm7e6CeOCZNXz55kd5675TmDs562hGTulI6nonr7rnLa+CWLVhM4+/uIHla9uzDmVETUz/3foUIfOWV0GUxoAmF/zUmbfs0ci8ObOYPX2HrEOxjDl5FURpDGjyuGInr4OmNTL37TOyDsNqgHcbC6K0G+WTlq1eOHkVxNYtr6LOUE291N7Dzx96jrufWJ11KJYxJ6+CKB19K/qW19J1PZz1s0f40e+WZR2KZazY/6bryNv3n8aEsY3sv8skXlrfd/28muipEpZy8iqID82ZzofmTAeg9cmMgxlBpRn2nqRq3m20XCnNsN/Q4dOD6p2TV0Hc+/RLLHxuLVu6i/njGyWeYW8lTl4F8ZfX3cf7vreAzVuKnbzGN4IEGzZvobvH1/SqZ05eBbB5SzcdXT00NogJzcW+qkSDxKSxjUkC8ylCdc0D9gVQfmpQPVwe+Z7zjmBC0xgaGorfV+udk1cB1Nvs+pax/tiadxsLYdt5jf5SW/1w8iqA9VtPDaqPLa/v3L6E91x+F/Mf788PrFtROXkVwLo6S14vrGvn0efXs2JdR9ahWIa8n1EA8167K3ec/Wc0jamP/0WlsT3P9apvTl4FMKG5kX2mtWQdxqgpXbPMpwjVt/r4V22FskN6gqMvBV3fnLwK4PoFS/nsDQ9x39I1WYcyKkpbXv75s/rm5FUA9y1bwy8eXs6L6+tjALt0wUXvNtY3j3kVQL38+EbJXjtP5IQ3TeeA3Qv8G2/WJyevAqi3Gfb77dLCxR86KOswLGOZ7jZK2l3SryT58gBD4Bn2Vo8y+7RLOh74DjDggQtJrcAuQGfFon+MiB8PPbp8qZfr15dEBItXbGB9exf/Z58pWYdjGcnyX/WXgHnAV4D9BtH+2IhYNqwR5VBEsD69quikgv9mY7n3f28Bnd09LL7waMY1FfsyQFZdlsnr0IjYUg+XcBlJnd09vHP/qXR09dDcWB8HjyUxeXwjq9s6Wd/e5eRVpzJLXhHhSTrDYGzjGK77+CFZhzHqJo9vYnVbJ+vau9hl8risw7EM5HmE9/OS3gJMBlYC10XEdb1VlnQGcAbAtGnTaG1tHZUgs9DW1lbY/m3tW2c7AK333MfzOxVny6vI791wy2vyWgs8CZwHdADHAz+RdGBEnFOtQURcDVwNMGvWrJg7d+4ohTqyOrq6adu8hcnjmrbuNra2tlKU/lUq9e26p+/j6XWr2PeA1zH3NbtmHdawKfJ7N9xyOUgSEcdFxGURsTEiuiPiRuBa4CxJe2Ud32i6c8kq3vSNX/M3P30g61BG1bYrS3j0oV7lMnn14l6S/rw560BGU+lI4+Q6OtIIPkXIcrjbKKkZGB8R6yoWdaf3xRkA6Yd6uxBhySf+bF9Oecve7L6jB+vrVc1veUmakiaskrcB/1al6pz0/qGRj6p21NsloEum7zSBWbtNqrstTtumppOXpBnA88AvKhYdIendZfXmAn8N/EtEPDF6EWbPpwZZvcry9KBLSGbY75U+fjhddEhElE77aQfWAMvLmj4IfBH4sqSLgIkkpwl9A7hkFEKvKfV2UnbJouXrufbupey3Swtnzt0363AsA1lOUv1CP+qsAPaoKFsP/GN6q3v1djmckjUbO7npwed4275TnLzqlPc1cu4zR+zHB964Jwe/asesQxlVPtpoTl45N3v6jsyeXl+JC8rmefk69nWrpgfszXrj69ibk1fO/eNtj/P91qfo6u7JOpRRNSk9urq+o4ueHl/Lsh45eeVYV3cPl93xJJf8z2LG1NmlhRrHNNAytpEIaOv01lc98phXjm3o2HaksaGhvpIXwCEzdqZzSw9dW+prq9MSTl45tm2Can1Nkyj54cfq6jRWq+Ddxhyrt2vXm5Vz8sqxbSdl1+cGdE9PsG5TF+2d3X1XtsJx8sqx0hynet1t/OJNCzno727jl48s77uyFc6wJi9JVw7n+mz7hNh9h3HsWqfXcN8618sTVevSgPY3JH20jyrHDiEWG6B3z96dd8/ePeswMuNThOrbQAdLrt/OMs8UtFG1bZa9k1c9Gmjyeow/3bqaCLwG+AvgiuEIyqw/tp3f6Emq9WigyeszEfFMlfJFkm4FbgDmDz0s64/P/9vD3LlkNd/+wOs58rXF+QWd/ipdBsi7jfVpQAP2EfGb7SxrJ9kCs1Gyuq2T1W2bGTOm/mbXQ/kvCDl51aOBDti/s1oxsBNwHMlvKNooqfcZ9vvt0sI//fnB7L7D+KxDsQwMdLexleoD8wKeA04eakDWfxvqfIb9zhObef/Be2YdhmVkoMnrKeC0irJuYCXwVER4qvMoqvcZ9lbfBvqpvyIifjsikdiARETdz7AHuG7BUl7e2MmnDt+f5kafMFJPBjpg/92RCsQGpr2rm67uYGxjA+Oa6up3dl/h8jue5LI7nvQRxzrk/Y2capD423cfQFd3fc8N3mF8E2s2drK+o4tpk8ZmHY6NIievnBrXNIbT3rFP1mFkrvRju54uUX88SGC55omq9cvJK6f+uGYTv3j4eRY+tzbrUDI12acI1S0nr5y6/5k1fPaGh7n27qVZh5Kp0pFWb3nVHyevnFq3ydMkAKa2NDO1pZn6PEGqvnnAPqdKu0n1Oru+5OyjZnH2UbOyDsMy4C2vnPLseqt3mSYvSbtL+pWk+p6sNAjr6/ykbLPMkpek44HfAfsOsv3nJC2StFDSg5KOG94Ia1vp1KB63228f9ka3vqt33D6j+/POhQbZVlueX0JmAcsGGhDSV8C/hZ4b0TMBs4F/l3SMcMbYu1a377t17Lr2ZgG8cK6Dl5c76sx1ZssB0wOjYgt0sCOE0naEfgqcGlEPAUQEbdLug34B+DWYY+0Bv3ktP9DW8cWxjXX97ClL0hYvzJLXhEx2FmFRwMT+NPLTd8B/IOk10TE4u2toLMHFq9YX3XZXjtPYEJz8rK8uL6Dlzd1Vq3XPKaBfaa1bH38+IoNRC+/QbLLpHHsPLEZSKY4vLC+vdfYZu4yiYaGJKE/89JG2ruqX2Vo8rgm9tjRF+ErbXm+vKmLxSvW0zK2kek7TQCgc0sPT69u67Xt9J0m0DI2ea9Xbuhgzcbq73VjQwP77bLtvX7ixQ10R/X3emrLWKa2JOdYru/oYvna3t/r/aa10Dgm+efzxzWb2Ni5hT9u6PmTz2be+zRS8nioanZ6Xzk7c2nZ8u0mr+VtPRz93buqLrvpzLcy59U7A3Dl/Cf50e+qXbIfZu06if85a9uFZd9z+V29niR9/ntfy8cOnQHAbYtW8IUbF/Ya25JvHENzmrzO+tnDPPhs9Rn0H3zjdC494aBe11Mvdig7Pejo797F0QfuxlWnzAGSfz69vc8APz71EN45cxoA1y9YxpWtT1Wtt+eO41nwpcO3Pv7wP/+OtZuqb+l94V2z+ORh+wGw4InVnPnTB3t9/oe+Oo+d0n9qX/7577nridXJggWvjLkQfRoBeUxeU9P7DRXlpX9XU6o1knQGcAbAuF1nML2l+u7qo488xIalySVm2lZ39lqvhU20trZufbz7BNHTyzHTF555itauJAk+++KWXtcJcOedv6UxTV5juzp6rdu59sVXPH+5tra2XpflXbW+Hb13E4+uTv7D97St3rr85Y6e7b7Wj/9hIT3Lk/d67YquXuvuOKbzFc85rbmblobqdVc9t5TW1ucAeGp193af/557FjCxKVne0L6Z6S2iu6eHMQ2vHArIe5/KVd8UGKSIyPRG8luQMYD6V5NcinpKRfm8tPzMvtYxc+bMKLL58+dnHcKIKXLfIorfP+D+GKbckcfR3tJ26KSK8tLjl0YxFjPLSB6TV2nAaO+K8hkVy82swGo+eUmaIqm5rOhXwCZgbkXVw4BF0ceRRjMrhppOXpJmAM8DvyiVRcRa4ELgk5L2SesdCbwLOCeLOM1s9GV2tFHSJSSD7Huljx9OFx0SEaXJKe3AGmB5eduI+LakDuAWSVtIfn7twxFRFxNUzSzbSapf6EedFcAevSz7LuBfMzKrUzW922hm1hsnLzPLJScvM8slJy8zyyUnLzPLJScvM8slJy8zyyUnLzPLJScvM8slJy8zyyUnLzPLJScvM8slJy8zyyUnLzPLJScvM8slJy8zyyUnLzPLJScvM8slJy8zyyUnLzPLJScvM8slJy8zyyUnLzPLJScvM8slJy8zyyUnLzPLJScvM8slJy8zyyUnLzPLJScvM8slJy8zy6XGrJ5Y0i7Ad4A3pUW/Bz4XEc/1o+0yYG2VRedExK+HLUgzq1mZJC9JzcDtwBLgQCCAHwLzJb0hItr6WkdEHDyyUZpZLctqt/EvgdnAuRGxJSK6gXOBfYAzM4rJzHIkq+T1QeDZiHi6VBARK4BF6TIzs+3KasxrNskuY6WlwBH9WYGki4HDgcnAMuB7EfGf26l/BnAGwLRp02htbR1YxDnS1tZW2P4VuW9Q/P4Nq4gY9RvQCfyySvlPSMa/xvfR/j7gI8BYoAn4ZNruU/15/pkzZ0aRzZ8/P+sQRkyR+xZR/P4B98cw5ZHMjjb2Qv2pFBGHVBRdIelY4CJJ10REx/CHZma1JKsxr9XApCrlk4BNEdE+iHXem7Y/cCiBmVk+ZJW8FgJ7VymfQTLfq1eSxktqqbKoO70fM7TQzCwPskpeNwOvlrR3qUDSrsABwE3lFSXtKqk8zhOBS6uscw6wmeSIpZkVXFbJ63qSLay/l9SYJqdvkxxt/H6pkqRDgeXAFRXtPyLpzWX1TgSOAy6OfkxwNbP8y2TAPiI6Jc0jOT1oEcmRwkeBwyuSTxuwDnihrOxW4BLgSklNwI7Ay8AnIuLq0YjfzLKX2dHGiHgR+Is+6jwC7Fyl3YXpzczqlK8qYWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmueTkZWa55ORlZrnk5GVmuZRZ8pK0i6SfSno8vd0oaXo/2zZJulDSYkmPSrpH0ttHOmYzqx2ZJC9JzcDtQDNwIPBaYCMwX1JLP1ZxOXAi8I6IeB3wQ+B2SQePUMhmVmOy2vL6S2A2cG5EbImIbuBcYB/gzO01lDQLOAP4dkSsAoiIa4CngW+OaNRmVjOySl4fBJ6NiKdLBRGxAliULtue4wEB8yvK7wCO6ueWm5nlXFbJazawtEr5UuD1/WjbAzxbpW0jyS6omRVcY0bPOxV4oEr5emCCpPER0b6dtpvSXc3KtgBTqjWSdAbJ7ibAZkmPDjDmPJkKrM46iBFS5L5B8fs3a7hWlFXy6o1Gqm1EXA1cDSDp/oh40xCeq6YVuX9F7hvUR/+Ga11Z7TauBiZVKZ9EslXV21ZXqe0ESWOqtAV4aRjiM7Mal1XyWgjsXaV8BvD7frRtAF5Vpe0W4LGhBmdmtS+r5HUz8GpJe5cKJO0KHADcVF5R0q6SyuP8ORDA3Ip1HgbcFhEb+vH8Vw885Fwpcv+K3Ddw//pNETFc6+r/kyaTVO8n2Uo6ieTo4bXA24E3RERbWu9Q4E7g6og4s6z9VSTJ6tCIWC3pVOAK4K0R8fCodsbMMpHJlldEdALzgG6SuV2PAZOBw0uJK9UGrANeqFjFp4F/BxakRw1PB45y4jKrH5lseZmZDZWvKmE1Q9Lukn4lqXD/UYvct6wUJnkV/SoVQ+zfMkkPV7kdOdJx95ek44HfAfsOsv3nJC2StFDSg5KOG94IB28ofZPUmvar8r376PBHOnCSDpb0A0kPSHokjfUySdP60XZo37uIyP2N5OoUj5CMgzUCY4AfAU8ALf1ofxWwBJiWPj4NaAcOzrpvw9S/ZVn3oR8x3gvsD1yffCwH1PZLJPP/9k0fzwO6gGOy7tcw9K0V2DvrPmwnvsUkMwQmpo/3TMuWAOP7aDuk713mnR+mF/B0kukT+5SV7UZyQOALfbSdRXK089SK8j8A/5V134bav7Tusqz70I8YG9P7AX3BgR1JLqf0dxXl/wX8Iet+DaVvaZs8JK/9Ksr+Kv28fnA77Yb8vSvKbmPRr1IxlP7lQkRsGWTTo4EJVH//XivpNUMKbBgMoW95MDsinqwoW57e77SddkP+3hUleRX9KhVD6R8Aki6WdL+kJZJuk/S+YY0wO7PT+8rXZ2nF8jz7vKT70rGhOyV9POuASiKZ9lRpJsmW153baTrk711RktdUoNrM+q1Xqeij7YCvUjHKhtI/gJXAQ8ChJFeu/QXwC0lssJ/MAAADhklEQVSfGtYoszE1va98fWrp/RuKtcCTJJOyDwQuA74v6R8yjaoX6TnHpwLXRsSS7VQd8veu1q4qMdxG7CoVNaJfMUbEIRVFV0g6FrhI0jUR0TH8oWUuD+9fnyKi8qjpjZIOA86SdFlEVG65ZO2rJOcYnzXI9v1+34qy5VX0q1QMpX+9uTdtf+BQAqsBpWtfVb4+tfT+Dbd7Sb67b846kHLp7uwJJEd52/qoPuTvXVGSV9GvUjHo/kka38vgZ2lzvfLDkzcL0/u9K8pnVCzPHUnNknaosqjm3jtJpwBnk5zit7IfTYb8vStK8sr6KhUjbSj9OxG4tMo65wCbSY5Y5oakKemJ/SW/AjZR/f1bFBGLRyu2oarSt7cB/1al6pz0/qGRj6pvkk4m+QGdI9Oj4Eh6T3r14lKd4f/eZT1PZJjmmjSTZPKfkYzjNQDXUTGJk2TAuhv4fkX7q4DHganp41OpvUmqg+of8DGSQdA3l5WdSHKk5+9Gqw8D6Ov19DIXiuS/cgdwa0X5l4BVpPPggCOpoUmqg+1b+sXeAry7omwj8OOs+5PGc1L6XTkHOLns9s/A+dHL5zItH9L3rhAD9hHRKWke8B2SLYkAHmVgV6n4OslVKrpIjlzVzFUqhti/W4FLgCslNZFM6nwZ+EQkl8auCZIuIZkZv1f6uPTaHxLbDse3A2vYNo8IgIj4tqQO4BZJW0i+KB+OiFtHJfg+DKFvDwJfBL4s6SJgItAJfIPkPa0FlwPjqB7PBen9iHzvfFUJM8uloox5mVmdcfIys1xy8jKzXHLyMrNccvIys1xy8jKzXHLyMrNccvIys1xy8jKzXHLyMrNccvIys1xy8rKalv5W5XpJPZJ+nZZdIellSUslnZZ1jJYNn5htNU/Sh0mua3V6RFwj6dXAL4G3Rd9X7LSCcvKyXJB0M8l1ug4GfghcFBG3ZRuVZcnJy3JB0m4k1zLrBm6JiJr5+S/Lhse8LBciubzwBSQ/mVX5Q6VWh7zlZbmQXv+8FRhPckXSAyNi9XYbWaF5y8vy4rMkP/l1HMllh/8p23Asa97ysponaV/gRpKji+2S/prkxxveGxG3ZBudZcVbXlbTJH0TuBvYjeTXZQD+Jr3/qaQbMwnMMuctLzPLJW95mVkuOXmZWS45eZlZLjl5mVkuOXmZWS45eZlZLjl5mVkuOXmZWS45eZlZLv1/YIpejSE/6bgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the initial conditions.\n", + "pyplot.figure(figsize=(4.0, 4.0))\n", + "pyplot.title('Initial conditions')\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('u')\n", + "pyplot.grid()\n", + "pyplot.plot(x, u0, color='C0', linestyle='--', linewidth=2)\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 2.5);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Changing just one line of code in the solution of linear convection, we are able to now get the non-linear solution: the line that corresponds to the discrete equation now has `un[i]` in the place where before we just had `c`. So you could write something like:\n", + "\n", + "```Python\n", + "for n in range(1, nt): \n", + " un = u.copy() \n", + " for i in range(1, nx): \n", + " u[i] = un[i] - un[i]*dt/dx*(un[i]-un[i-1]) \n", + "```\n", + "\n", + "We're going to be more clever than that and use NumPy to update all values of the spatial grid in one fell swoop. We don't really need to write a line of code that gets executed *for each* value of $u$ on the spatial grid. Python can update them all at once! Study the code below, and compare it with the one above. Here is a helpful sketch, to illustrate the array operation—also called a \"vectorized\" operation—for $u_i-u_{i-1}$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![vectorizedstencil](figures/vectorizedstencil.png)\n", + "\n", + "
\n", + "#### Sketch to explain vectorized stencil operation. Adapted from [\"Indices point between elements\"](https://blog.nelhage.com/2015/08/indices-point-between-elements/) by Nelson Elhage. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute the solution using Euler's method and array slicing.\n", + "u = u0.copy()\n", + "for n in range(1, nt):\n", + " u[1:] = u[1:] - dt / dx * u[1:] * (u[1:] - u[:-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the solution after nt time steps\n", + "# along with the initial conditions.\n", + "pyplot.figure(figsize=(4.0, 4.0))\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('u')\n", + "pyplot.grid()\n", + "pyplot.plot(x, u0, label='Initial',\n", + " color='C0', linestyle='--', linewidth=2)\n", + "pyplot.plot(x, u, label='nt = {}'.format(nt),\n", + " color='C1', linestyle='-', linewidth=2)\n", + "pyplot.legend()\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 2.5);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hmm. That's quite interesting: like in the linear case, we see that we have lost the sharp sides of our initial square wave, but there's more. Now, the wave has also lost symmetry! It seems to be lagging on the rear side, while the front of the wave is steepening. Is this another form of numerical error, do you ask? No! It's physics!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Dig deeper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Think about the effect of having replaced the constant wave speed $c$ by the variable speed given by the solution $u$. It means that different parts of the wave move at different speeds. Make a sketch of an initial wave and think about where the speed is higher and where it is lower ..." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "* Elhage, Nelson (2015), [\"Indices point between elements\"](https://blog.nelhage.com/2015/08/indices-point-between-elements/)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/02_spacetime/02_02_CFLCondition.ipynb b/2-finite-difference-method/lessons/02_spacetime/02_02_CFLCondition.ipynb new file mode 100644 index 0000000..fdf727d --- /dev/null +++ b/2-finite-difference-method/lessons/02_spacetime/02_02_CFLCondition.ipynb @@ -0,0 +1,591 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth, C. Cooper. Based on [CFDPython](https://github.com/barbagroup/CFDPython), (c)2013 L.A. Barba, also under CC-BY license." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Space & Time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Stability and the CFL condition" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome back! This is the second Jupyter Notebook of the series *Space and Time — Introduction to Finite-difference solutions of PDEs*, the second module of [\"Practical Numerical Methods with Python\"](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about).\n", + "\n", + "In the first lesson of this series, we studied the numerical solution of the linear and non-linear convection equations, using the finite-difference method. Did you experiment there using different parameter choices? If you did, you probably ran into some unexpected behavior. Did your solution ever blow up (sometimes in a cool way!)? \n", + "\n", + "In this Jupyter Notebook, we will explore why changing the discretization parameters can affect your solution in such a drastic way." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the solution parameters we initially suggested, the spatial grid had 41 points and the time-step size was 0.25. Now, we're going to experiment with the number of points in the grid. The code below corresponds to the linear convection case, but written into a function so that we can easily examine what happens as we adjust just one variable: **the grid size**." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def linear_convection(nx, L=2.0, c=1.0, dt=0.025, nt=20):\n", + " \"\"\"\n", + " Solves the 1D linear convection equation\n", + " with constant speed c in the domain [0, L]\n", + " and plots the solution (along with the initial conditions).\n", + "\n", + " Parameters\n", + " ----------\n", + " nx : integer\n", + " Number of grid points to discretize the domain.\n", + " L : float, optional\n", + " Length of the domain; default: 2.0.\n", + " c : float, optional\n", + " Convection speed; default: 1.0.\n", + " dt : float, optional\n", + " Time-step size; default: 0.025.\n", + " nt : integer, optional\n", + " Number of time steps to compute; default: 20.\n", + " \"\"\"\n", + " # Discretize spatial grid.\n", + " dx = L / (nx - 1)\n", + " x = numpy.linspace(0.0, L, num=nx)\n", + " # Set initial conditions.\n", + " u0 = numpy.ones(nx)\n", + " mask = numpy.where(numpy.logical_and(x >= 0.5, x <= 1.0))\n", + " u0[mask] = 2.0\n", + " # Integrate the solution in time.\n", + " u = u0.copy()\n", + " for n in range(1, nt):\n", + " u[1:] = u[1:] - c * dt / dx * (u[1:] - u[:-1])\n", + " # Plot the solution along with the initial conditions.\n", + " pyplot.figure(figsize=(4.0, 4.0))\n", + " pyplot.xlabel('x')\n", + " pyplot.ylabel('u')\n", + " pyplot.grid()\n", + " pyplot.plot(x, u0, label='Initial',\n", + " color='C0', linestyle='--', linewidth=2)\n", + " pyplot.plot(x, u, label='nt = {}'.format(nt),\n", + " color='C1', linestyle='-', linewidth=2)\n", + " pyplot.legend()\n", + " pyplot.xlim(0.0, L)\n", + " pyplot.ylim(0.0, 2.5);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's examine the results of the linear convection problem with an increasingly fine mesh. We'll try 41, 61 and 71 points ... then we'll shoot for 85. See what happens:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "linear_convection(41) # solve using 41 spatial grid points" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "linear_convection(61)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "linear_convection(71)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So far so good—as we refine the spatial grid, the wave is more square, indicating that the discretization error is getting smaller. But what happens when we refine the grid even further? Let's try 85 grid points." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "linear_convection(85)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Oops. This doesn't look anything like our original hat function. Something has gone awry. It's the same code that we ran each time, so it's not a bug!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### What happened?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To answer that question, we have to think a little bit about what we're actually implementing in the code when we solve the linear convection equation with the forward-time/backward-space method. \n", + "\n", + "In each iteration of the time loop, we use the existing data about the solution at time $n$ to compute the solution in the subsequent time step, $n+1$. In the first few cases, the increase in the number of grid points returned more accurate results. There was less discretization error and the translating wave looked more like a square wave than it did in our first example. \n", + "\n", + "Each iteration of the time loop advances the solution by a time-step of length $\\Delta t$, which had the value 0.025 in the examples above. During this iteration, we evaluate the solution $u$ at each of the $x_i$ points on the grid. But in the last plot, something has clearly gone wrong. \n", + "\n", + "What has happened is that over the time period $\\Delta t$, the wave is travelling a distance which is greater than `dx`, and we say that the solution becomes *unstable* in this situation (this statement can be proven formally, see below). The length `dx` of grid spacing is inversely proportional to the number of total points `nx`: we asked for more grid points, so `dx` got smaller. Once `dx` got smaller than the $c\\Delta t$—the distance travelled by the numerical solution in one time step—it's no longer possible for the numerical scheme to solve the equation correctly!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![CFLcondition](figures/CFLcondition.png)\n", + "#### Graphical interpretation of the CFL condition." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Consider the illustration above. The green triangle represents the _domain of dependence_ of the numerical scheme. Indeed, for each time step, the variable $u_i^{n+1}$ only depends on the values $u_i^{n}$ and $u_{i-1}^{n}$. \n", + "\n", + "When the distance $c\\Delta t$ is smaller than $\\Delta x$, the characteristic line traced from the grid coordinate $i, n+1$ lands _between_ the points $i-1,n$ and $i,n$ on the grid. We then say that the _mathematical domain of dependence_ of the solution of the original PDE is contained in the _domain of dependence_ of the numerical scheme. \n", + "\n", + "On the contrary, if $\\Delta x$ is smaller than $c\\Delta t$, then the information about the solution needed for $u_i^{n+1}$ is not available in the _domain of dependence_ of the numerical scheme, because the characteristic line traced from the grid coordinate $i, n+1$ lands _behind_ the point $i-1,n$ on the grid. \n", + "\n", + "The following condition thus ensures that the domain of dependence of the differential equation is contained in the _numerical_ domain of dependence: \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\sigma = \\frac{c \\Delta t}{\\Delta x} \\leq 1\n", + "\\end{equation}\n", + "$$\n", + "\n", + "As can be proven formally, stability of the numerical solution requires that step size `dt` is calculated with respect to the size of `dx` to satisfy the condition above. \n", + "\n", + "The value of $c\\Delta t/\\Delta x$ is called the **Courant-Friedrichs-Lewy number** (CFL number), often denoted by $\\sigma$. The value $\\sigma_{\\text{max}}$ that will ensure stability depends on the discretization used; for the forward-time/backward-space scheme, the condition for stability is $\\sigma<1$.\n", + "\n", + "In a new version of our code—written _defensively_—, we'll use the CFL number to calculate the appropriate time-step `dt` depending on the size of `dx`. \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def linear_convection_cfl(nx, L=2.0, c=1.0, sigma=0.5, nt=20):\n", + " \"\"\"\n", + " Solves the 1D linear convection equation\n", + " with constant speed c in the domain [0, L]\n", + " and plots the solution (along with the initial conditions).\n", + " Here, the time-step size is calculated based on a CFL constraint.\n", + "\n", + " Parameters\n", + " ----------\n", + " nx : integer\n", + " Number of grid points to discretize the domain.\n", + " L : float, optional\n", + " Length of the domain; default: 2.0.\n", + " c : float, optional\n", + " Convection speed; default: 1.0.\n", + " sigma : float, optional\n", + " CFL constraint; default: 0.5.\n", + " dt : float, optional\n", + " Time-step size; default: 0.025.\n", + " nt : integer, optional\n", + " Number of time steps to compute; default: 20.\n", + " \"\"\"\n", + " # Discretize spatial grid.\n", + " dx = L / (nx - 1)\n", + " x = numpy.linspace(0.0, L, num=nx)\n", + " # Compute the time-step size based on the CFL constraint.\n", + " dt = sigma * dx / c\n", + " # Set initial conditions.\n", + " u0 = numpy.ones(nx)\n", + " mask = numpy.where(numpy.logical_and(x >= 0.5, x <= 1.0))\n", + " u0[mask] = 2.0\n", + " # Integrate the solution in time.\n", + " u = u0.copy()\n", + " for n in range(1, nt):\n", + " u[1:] = u[1:] - c * dt / dx * (u[1:] - u[:-1])\n", + " # Plot the solution along with the initial conditions.\n", + " pyplot.figure(figsize=(4.0, 4.0))\n", + " pyplot.xlabel('x')\n", + " pyplot.ylabel('u')\n", + " pyplot.grid()\n", + " pyplot.plot(x, u0, label='Initial',\n", + " color='C0', linestyle='--', linewidth=2)\n", + " pyplot.plot(x, u, label='nt = {}'.format(nt),\n", + " color='C1', linestyle='-', linewidth=2)\n", + " pyplot.legend()\n", + " pyplot.xlim(0.0, L)\n", + " pyplot.ylim(0.0, 2.5);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, it doesn't matter how many points we use for the spatial grid: the solution will always be stable!" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS8AAAEbCAYAAACLNQJjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl8VNX5+PHPk2SysyUQZIugsogSoqDWPaigiFK31rb6tZVaam1tqVrRWv2qra2tdaultWir/Wm/3dSqteJWCVC1KCiyBRABgbCEPfs65/fHnRmSYSaZZO6dO3d43q9XXpO5c5fnZGaenHvuueeIMQallPKaNLcDUEqpntDkpZTyJE1eSilP0uSllPIkTV5KKU/S5KWU8iRNXkopT8pw46AiUgp8GzgxEIMPeAv4sTFmVxfbbgL2R3jpFmPMWzaHqpRKUuJGJ1URWQOsAq4xxtSJyBDg31g1wfHGmIZOtt1kjBmemEiVUsnKzdPG2caYOgBjTCXwADASuNDFmJRSHuHKaSNQYoxpDlu2LfDYL9HBKKW8x5WaV4TEBTAKMMDCrrYXkV+IyBIRWScib4jIdNuDVEolNbdqXh2ISDowA/i9MWZdF6tXAR8BdwJ+YCbwkojcaIz5dSfHmBlYl+zs7AnFxcW2xJ6M/H4/aWmpeSE5lcsGqV++devW7TbGDLBjX6402B8ShMjdwMXA2caY2h5s/y/gTKDIGNPY1fqjR482a9eu7XacXlFeXk5ZWZnbYTgilcsGqV8+EVlqjJlox75cT/Eici3wRWBqTxJXwGKgF3CcbYEppZKaq8lLRP4HuBk4xxhTFcP6OSKSH+GltsBjup3xKaWSl2vJS0SuBmYD5xljdgSWXRRomwquM1BE2sd4JfBghN1NAJqA1Q6GrJRKIq4kLxG5CngCeBo4T0SuDiSzi4HBgXVOx+o+MSds8y+LyEnt9nUlcAnwizhOO5VSHuPW1cbHgGysjqnh7gk81gIHgO3tXpsX2OY3IuID+gL7gOuNMXOdC1cplWxcSV7GmIIY1vkYKAhbthP4ceBHKXUYc/1qo1JK9YQmL6WUJ2nyUkp5kiYvpZQnafJSSnmSJi+llCdp8lJKeZImL6WUJ2nyUkp5kiYvpZQnafJSSnmSJi+llCdp8lJKeZImL6WUJ2nyUkp5kiYvpZQnafJSSnmSJi+llCdp8lJKeZImL6WUJ2nyUkp5kiYvpZQnafJSSnmSJi+llCdp8lJKeZImL6WUJ2nyUkp5kiYvpZQnafJSSnmSJi+llCdp8lJKeZJryUtESkXkCRFZKiIfi8hqEfmViAyIYVufiPxYRNaIyEoReVdEzkhE3Eqp5OBmzesvQAFwljFmPDAZmAK8IyI5XWz7GHAlcKYx5njgD8CbIlLqZMBKqeTh9mnjbGNMHYAxphJ4ABgJXBhtAxEZDcwE7jfG7Aps+ySwAbjP8YiVUkkhw8VjlxhjmsOWbQs89utku0sBAeaHLX8buF5E8o0xtTbF6Dm7aprYXuvn010H/wT5WRkM7J0NQHOrny376qNuP6hPNrmZ1sdiT20T+xtaIq7nS0ujuDA39Hzj7jr8xkRctyA3k355mQDUNLZQtb+a9KYapLUejB8xbRDYdkjfXNLTBICd1Y00tbZ12Ffr/i2w+5NDDyJp1k9aBmT3hsxekOb2/2blJNeSV4TEBTAKMMDCTjYtAfzA5rDlG7HKMxZ4344YvWbpZ3v5wuPv4TfAfxaElk8bN4g5V50IwI4DjZz74IIoe4Bnv34KZ4zsD8DcRRv43YINEdcbVpDDolvPCT3//K//Q3Vja8R1Hzq1ict6rYbP3iVn60cc3RY9ebY3MMKyYoBlsWwt0GcoFJ8KR54GYz8PuQUxHVd5g5s1rw5EJB2YAfzeGLOuk1X7A/XGmLaw5dWBx8Io+5+JdbrJgAEDKC8vjy/gJFS+pQW/gex0Q9+sg7WO5updofLuafBzRK5E3UfFyo9prUwHYN+O5qjr5tPU4W9YmOknN63julmmie+ZZ7jso3+HlmUAraRTQy6NZNFGGoY0/FjbFmYLwd3sbzK0+A/uz2+sn96ZQp6vYzxi/ICfNH8r6W31ZLQ1woEtsGILrPgbTW/cQ8Wx32d/v/FRy54MamtrU/Kz6QQxUar6iSYidwMXA2d3dtonIm8ApxpjeoUt/wYwF7jQGDOvs2ONHj3arF27Nv6gk8xT72zknn+u5rziDJ684Xx3g6laA3//GuyqgPRMmDgDRpwFw06B3EKQ6Ak0mp+/tobfln/KD84fzbcnHdP5ym2tsHstfPYuLP8rbP0AEDhjFpxzJ6Sl96hYTisvL6esrMztMBwjIkuNMRPt2FdS1LxE5Frgi0BZDO1Vu4FcEUkPq30Fk9keJ2L0gunjBzPhyH6sXf6hu4E018Gzl0P1Vug/Ci7/PQwqiXu33yo7mmNlO1POGNH1yukZMPA462fiDFj4S1hwP/znYcjuA2d8P+54lLtcb9EUkf8BbgbOMcZUxbDJcqy4h4UtHwG0AhX2RugdhflZlAzty4Bcl9/WRQ9aiWvQeJhZbkviAuid7aN3lpDt62atKS0dymbDlc9azxc8ANXbOt9GJT1XP+UicjUwGzjPGLMjsOyiQPtUcJ2BItI+zn9gNeqXhe1uEvCGMabG2ahVp/Z8Cu8+Zv1+4YOQmeduPO2NmQZjLoKWOnjzLrejUXFys4f9VcATwNPAeSJydSCZXQwMDqxzOlb3iTnB7Ywxa7Hatm4Xkf6B9WYARwN3JLIMyeblj7dx+wsrWL0n/FpGAr12O7Q1w/ivwLCTbN31gnW7eHBJI08uinwFNCbn3wcZ2bDi71Z7mPIsN2tejwHZWB1Tn2n3M7PdOrXAAWB72LY3An/H6o2/EvgGMMUYE9NF9FS1ZNNe/vz+ZrbV+rte2Qnr34JPXrf6WJ13t+27r6puZMXuNiq2x1G57jccTv+e9fu8W0P9y5T3uNnPq8tON8aYj7FuIQpf3gL8KPCjApoC/Qp8bv1L+vAZ6/GMWdArUi+t+GQF2rrCO6522+mzYMlTsGMFbP8YButdZV7keoO9sk/wS+1L7343hLi1NMInb1q/l3zRkUNkplsf16bWOGuWmblw7MXW7xX/jDMq5RZNXikk+KV2pea1Yb7VED5oPPQtduQQWT6bkhfAsRdZj2teiX9fyhWavFJI8Eud4ca7WhFIAsEajQOyAgVrarHhgsTwM63+XrvWRL5XUiU9TV4pJHTamJbg08a2Vlj7qvX7GCeTV7DNy4aaV7oPRk21ftdTR0/S5JVCjizMY+yg3ofc9+e4ze9Cw14oPAYGjHbsMIV5mZxQlM4pR9l0g7WeOnpaUtwepOzx00vHAST+xt72p4w9uGcxVsP75/G9E7MpKzvWnh0efS5k5EDlUjhQCX2G2LNflRBa81LxMeZgzcXBU0ZHZObCMedav6/5l7uxqG7T5JVCWtr8JHyUkKrVUF0JvQbB4BMcPVSb37C30c+WvbGNBxaT4AWG9W/at0+VEJq8UshZv5jPUT98lT0NCexhv3WJ9Vh8quMjl9Y0tnBTeQPTfrXIvp0Wn2o9bl2ive09RpNXCmlq9WNMgq82Vi61HofaMkRTp2y92hjUtxjyBlgXHPZtsm+/ynGavFJIc7CTaiLH2asMjB02ZILjh8oM9PNqtvP0WORg7MFErDxBk1cKOdjPK0EHbK6z2rwkHY6wZ8yuzqSnCelind21tNl4ihdKXi4P4qi6RZNXimjzm9AXOmG3Nm7/GEwbDBxrXblLgGBijvvm7PaGWJOTULnEvn0qx2nyShHBU8asjDTEwb5WHQRPsxJwyhh0MHnZ2O41OJC8tn8MbZGnelPJR5NXigjWRLISeWNjKHk531gfFBwxw9bklVsABUdDa6N1Gqw8QXvYp4hsXzq/uLzEmo639tPEHNSFmtd147IoKRlPYWASW9sMmQB7P7XKNCi5p0dTFq15pYhsXzpfPGkYX5wYPi+JQ2p3wf7N4Mtz9H7GcGML0zljZP/uT8LRlWAC3qpXHL1Ck5fqmWCta/AJSTsHYrdodwnP0eSVInbVNPH/3tvE66t2JOaAoVPGExNzvICFW1v42bwKPttTZ++OjxgHaT5rfK8mnYDKCzR5pYjNe+u566VV/LY8we1dCehZ395/t7fyuwUb2Gzn/Y0Avmw44njAwLaP7N23coQmrxSR8KuNO1ZYjwlu3A7e+hScbMRWwbLsWGn/vpXtNHmliGDXgaxE3BtUtxvqqiAzH/o4M159NI708woqOs561O4SnqDJK0W076TquOCXe8AYx0eSCBdMXs1tDkysWxQY5FCTlydo8koRTQlNXhXW48Cxzh8rTKiTqhOnjUWB8lStAb9LE/eqmGnyShHBGXUyE1nzKkp88spw8rQxrxDyB1pTuB3YbP/+la00eaWIVr9B5OCYV47a6V7y6pMpDO2XQ7ZTQ2cEy7RTTx2Tnd4elCK+fHIxXzppGH4DixYucO5Axhw8bXQheX3+mEwevq7MuQMUjbUm0K1aDWMudO44Km6avFKIiDg/HM6BLdBcY40+mj/A4YO5INiOp432SU9PG1X3hGpdNk0/lmxCVxwr3I1DdcnV5CUig0TkNRHRmQ/i9OSiDUx9dBF/X7LF2QO52FgPsGBrC+PveYOfvOJQzWjAGEBg9zpobXbmGMoWriUvEbkUeA84ugfblovIahFZFvZzjf2ResO2/Y1UbK/mQIPDg+m52FgPVpPbgYYWaptanTlAZh70Gw7+Vtiz3pljKFu42eZ1GzAZuAM4pgfbX2iM2WRrRB7W4fYgB/pvhrjYWA8O97APKhoL+zZatUwX+rKp2Lh52ni6MeYTF4+fUg52UnWwq0RbK+xea/1eNMa543QidG+jnWPYhws12mu7VzJzLXkZYxyq9x+eDt7b6OBbuvdTaGu25jrM6uXccToRvHXTkR72QXqbkCd4+WrjTSLyvoisEZGFInKt2wG5qTkRo0qEGuuPc+4YXTh4b6OTyUtv0PYCr/bz2g+sB24HGoFLgWdF5DhjzC2RNhCRmcBMgAEDBlBeXp6gUBNj+85GANZWrOLonEZHyjd846sMBz5rzGWjS3+/1qZGQNi5e69j76H4WzlTMkjbt4lFb82jLSPHkeNEUltbm3KfTad4MnkZYy4JW/SciEwCvi8ivzLGHHJjmjFmLjAXYPTo0aasrMz5QBNoc9Ymxu2o4cLThlNZsRRHyrfjCQCOnDiVI0sc2H8M9r72Nj84v5ih/XIoKx3i3IHWjIaqVZw5pgiGJm6CkfLycmfeuxTkyeQVxWLgBuAk4LC7q/aaU4eHfq90qp3ZxdEkggqy07isrCcXp7tp4FioWmWdOiYweanYea7NS0QyRaRPhJeCl59SYDaIJNRcD3s3QFoGFI50OxrnaaN90kv65CUihSLSfpK+04C/RVg1+O/xsByAfMXWA3y8ZT+NLQ51Idi9FjBQeAxk2DxnYjc0txnmrdjOaysdnmikSO9xTHZJnbxEZARQCbwU9tK5IjKt3XplwDeBZw7XvmPf/r8P+fycd9hZ3ejMAVzuWR/U0Arf+tOH/OjFFc4eSIfGSXqutXmJyANYPeyLA8+XBV462RgTvKmsAdgLbGu36YfArcAPReSnQB7QDPwEeCABoSelgz3sHTprdvmexqBQD3sn+3kB9BlmjdFfV2WN2Z/X39njqW5zLXkZY34Qwzo7gMFhy6qBhwI/KiDYSdWxkVSDycvl22UcHUm1vbQ0q91r6wdW2Uec5ezxVLcl9Wmjil2wJuJYJ9UkGQqnfSdVv9/hwUh0eJykpskrBRhjnJ23sX4v1GwHXy70HW7//rtBREK1S0d72YM22ic5TV4poNVv8BtITxMy0h14S4M1DxemOoskmKAdb/fSRvuk5v4nUcXN8Tkbk6SxPih4UaLJibkb2ytqN7qE0fEyk00q9bA/bGX70nnj+2fR2ubQFyxJGuuD3rrpLHzpaeRmOtwfOX+ANVZ/3S5r7P6+iZ0dXHVOk1cKSE8TRg10cIiaJGmsD+qbm8BOskXHwsZd1t9Ak1dS0dNG1TljkqaDqitC7V6r3I1DHUKTVwqo3N/ATX9dxsNvrrN/59WV0HQAcgqs2aSTwD3/XMWVv3uPtTtqnD+YJq+kpckrBeypbeKFjyr595qd9u+88kPrcXApiNOTQsZm1bZqFm/cy776BMzuM7jUetx2WN4ym9Q0eaWAZifHr69caj0OSZ5hYUJdJZzuZQ9WzSsj2xoCu36v88dTMdPklQKanOwqkZTJK9BVwqkRNNpL98Gg8dbv2z50/ngqZrZ+2kXkN3buT8Um2Lve9vsa/W0HT5eSKnklsOYFB8teqckrmXSrq0QMk7peGEcsqoccu69x9zporoU+xZBfZO++4xAsZ3PCk9fSxBxPxaS7/bye7uQ17YLsEsfmbAydMp5o737jFJzeLfE1r6VW15EkuXBxuOtu8qrg0NpVHjAG+Aowx46gVPf0yfFxYnFfRvTPs3fHSdjeBTB+aF9qGlsZVpCgWX36Dbe6imhP+6TS3eT1XWPMZxGWrxaRecBfgPnxh6W6Y9KYIiaNceC0busS6zHJkteXTi7mSycnMIGIWH+D9W9afxNNXkmhW40kxph/d/JaA1YNTKWClgarY6akHbzadjjTdq+k090G+0jDSQrQD7gEawJYlWChq43paYhd7THbl4Npg4HHQ1a+Pfu0SXVjC3tqm8nPymBAr6zEHHToROtRrzgmje6eNpYTuWFegK3A1fEGpLpvztvr+dXb65l13khmnTfKnp0maWM9wF/f38J9r1Zw3Rkj+NFFCbrfcnDg77B9GbS1QrqOaeC27r4DnwLXhS1rA6qAT40xCeg1qMI5crWxMjnbu8CFq40AeYVWw/2+TbCrAo4Yl7hjq4i6m7zmGGMWOBKJ6jHbe9j722BD4G0eerI9+7RRZnoweSX4f+Wwz1nJ69P5mrySQHcb7B9xKhDVc6Hk5bMpeW1ZDPW7rZpGkozh1V6wnAnrpBo0eqr1uOaVxB5XRaT3NqYA2+dsrPin9XjsxUnZITN0b2Oik9cx51k3aW9ZDDUOz9ituqTJKwXYOoa9MVARqFmMuTj+/Tkg4fc2hg6cD0efY/2+5l+JPbY6hCavFGDrhLPbP4YDm62BB4eeFP/+HJCZ4VKbF8CYi6zHYO1UuUav96aAGaePYMrYgRw/pE/8Owu254yZlhTTnEUybkgf/nTdKRTkJXAs+6DRU0HSYdMiaNgHOf0SH4MCNHmlhFOPLgQK7dlZ+/auJNU3N5PTj+nvzsFzC2D46bBxIax7HcZ/yZ04lJ42qnZ2r4ddayC7Dww/0+1oklewLVBPHV2lySsFPL90K398dxP76uIc0/2DJ6zHURdYI4gmqX11zfz01QoefesTdwIYM816/ORNq9+XcoUmrxTwm/L1/O/Lq9hT19TznexcDe8/Yd2Ifep37AvOAfUtbcxduIG/fLDZnQD6DIFxX4S2Jnj9DndiUO4mLxEZJCKviYgOZBiHuG8PMgbm3WrdiD1xBgwqsTE6+7nWVaK9yfdCZr51gWN91MFWlINcS14icinwHnB0D7efJSKrRWS5iHwoIpfYG6F3xH170OoXratnOQUwKflrEqHklYgJOKLpPQjO+oH1+7zZ0JqAadhUB27WvG4DJgPvdHdDEbkN+BFwsTGmBJgN/F1EptobojcEv8Q96ue1YwW8drv1+7l3WlfTkpxrPezDfe4GKDwG9nwCr2kCSzQ3k9fpxphut7iKSF/gTuA3xphPAYwxbwJvAL+0N0Rv6NFpozHw38fhiXOgZjsMOwVO/KpDEdrLly6IQKvf0OZ3scUhIxOmPWj1+1ryB/jDFNjzqXvxHGZc6+dljGnt4aYXALkcOtz028AvRWSMMWZNZzvwtzaxcdXiiK8d0SeHHJ+VBPbUNlHd2BJxvYz0NIb1yw0937i7jmhzkBTkZdEnx7p6V9PYyu7a6GM2HlmQR1qadT/htv0NUXuR52X5KOqVhTGG4W2bQCBzTwUI5NVugh0rrXj8bVZbVksDNFZDXRVs+cA6TdwfGNF74gyYch+kOTBprQNEhKyMNJpa/TS3+snJTGfL3nrqmiN/pPIyMxhWYL1XLW1+Pt1VG3XfQ/rm0Cvbeq921TRFvQiSkSYcU9QLjiqDGa/R8rcZ+LZ9hH/O52gceCL1gz9HU7+R+LN6k9+7gH75uZCWTl2zn6ra6DW0rJqNsHMAADsONNLQErlMOb4MjuiTHSrT1n31UfdZ1CubvCzrq763rpkDDZGPn54mFBccnAdh8966qP8c+uRkhjoJ1zW1UlUT/TM9tF8uvnT760le7KQabE3eGLZ8Y7vXO01efRq2MOLvU7o8UHe6fo6Icb1egZ9YDI5hHQFeDw4m+jvr4SSAJTFsnNsfLnoYxk6PMaLkke1L5yeXjKPV7wfSueefq3iroiriupNGD+Cpa62hffbVN3PBI4ui7veJayYyeexAAP5v8WYefmtdxPX652ex5EfnWU+Gncz5jffx3bbHuYR3yd3+X3K3/zfidnl0/lkZARAYB/KITtZrz9fFPtsrCPzEItaR+rsqk1O8mLyCXatrwpZXBx4j5hsRmQnMBDh+UDafMizizguyBV+6VfOpafZTH7niRUYaFOYc/G9SVeePOvdbr0wh12fts6HVUN0U/VRnYK6ERnLY2+CnJUqzTk4G9M6yjt/qN9S3mNBzv99PWuDWHiNpQBpt6Vm0ZuTRmpFHbf7R7O87lrq8EZiqdKgqjxpPsqmtraW8vJxzh0Dm7k9Y+t/1AJi6JobmRx4BQ+r3UV5eDkBNs4m6HsD6ipX4qioA2LOtJeq6eb6W0D4BsnyZ/NLcyBPmq4wz6yg1FRSxh3zqGZTZQF+fQYyfpjY/+xr9RIugMNuQkW7VgPc3+mmKck0iKx36Zgfeb2PYVR/9M9U3S8jKsI5Y12yobYm8bprAgNyDn+ld9X6inZXn+YT8TGufTW2G/Y3Rjz8gR0JnE7Ai6nrdZoxx9QdrLkjTjfXnYp2fFYYtnxxY/q2u9jFq1CiTyubPn+92CI5J5bIZk/rlA5YYm3KHFzup7g48hp99BZ/vSWAsSimXeDF5LQ88Dg9bPiLsdaVUCkv65CUihSLSfuyT14B6oCxs1UnAatPFlUalVGpI6uQlIiOASuCl4DJjzH7gx8C3ReSowHrnAecDt7gRp1Iq8Vy72igiD2A1shcHni8LvHSyMSbYEaUB2Atsa7+tMeZ+EWkEXhGRVqzp175gjJmXkOCVUq5zs5PqD2JYZwdRujsZayYjnc1IqcNUUp82KqVUNJq8lFKepMlLKeVJmryUUp6kyUsp5UmavJRSnqTJSynlSZq8lFKepMlLKeVJmryUUp6kyUsp5UmavJRSnqTJSynlSZq8lFKepMlLKeVJmryUUp7kxXkbE6K6upqqqipaWqJM3JjE+vTpQ0VFhdthOKInZfP5fBQVFdG7d2+HolJu0OQVQXV1NTt37mTIkCHk5OQgEn2S0mRUU1NDr16xzsvtLd0tmzGGhoYGKisrATSBpRA9bYygqqqKIUOGkJub67nEpToSEXJzcxkyZAhVVVVuh6NspMkrgpaWFnJyctwOQ9koJyfHk00AKjpNXlFojSu16PuZejR5KaU8SZOXUsqTNHmppPH4448zduxYRISnn37a7XBUktPkdRioqqqitLSUgoICRITS0lKefPLJbu1j9uzZTJw4scOyZcuWcffdd7N///4Oy5uamhgxYgSPPvpot45x/fXX8+qrr3ZrG3X40uR1GCgqKmLZsmVMnz4dsJLOdddd1+19FBcXd1i2bNky7rnnnkOSV0ZGBsXFxRQWFsYXuFKd0E6qKiY333wzN998c0zrpqens2DBAocjUoc7rXkdxoKnksOHD2fevHmcc845DB06lMmTJ7N169bQet/+9rcpLi5GRNi0aRMAd9xxB3fddRcAF154IaWlpVxxxRXs2bOH0tJS8vPzKSsrC+2jsbGR2267jQkTJnDiiSdSUlLC9ddff0itTalYafI6jAVPJfft28d7773H22+/zZo1a9i8eTO33npraL05c+Zw7733dtj2vvvuCy179dVXWbZsGc899xyFhYUsW7bskPax/fv389RTT/Hiiy/y4Ycf8v7777N3716uueYa5wuqUpKeNnbD8Nv+FfW1n146jq+cYrUJ/d/izfzwHyuirrvp/mmh3y96bBErK6sjrvflk4fxs8tKAFix9QDjhvbpSdhdqqmpYdasWQDk5+czefJkXnjhBVuP0b9/f959912GDRsGQHZ2NjNmzGDq1Kns3LmTgQMH2no8lfpcS14iUgQ8DAT/Ra8AZhljtkbfKrTtJiDS+cYtxpi3bAvyMNG/f38KCgpCzwsKCti5c6etx8jIyGDdunXccMMNVFZWkpGRQW1tLQAbNmzQ5KW6zZXkJSKZwJvAOuA4wAB/AOaLyAnGmNqu9mGMKXU2ykO1rzF15iunFIdqYV155cYzY1rPqVoXQG5ubofnaWlp+P1+W48xb948pk2bxkMPPcT3vvc9RITy8nImTZpEU1OTrcdShwe32ry+CpQAs40xrcaYNmA2cBTwLZdiUg565plnyM/PZ9asWXqfobKFW8nrcmCzMWZDcIExZgewOvCa8gCfzwdYY2YBvP766+zduzfiuk1NTaSldfy47dixw9kAVUpzK3mVABsjLN8IjItlByLyCxFZIiLrROQNEZlua4SqSyNGjABg69at1NTUcOmll1JTUxNx3WnTpnHgwIFQz/6amhoeeeSRhMWqUo9bDfb9gaURllcDuSKSY4xp6GT7KuAj4E7AD8wEXhKRG40xv460gYjMDKzHgAEDKC8vj7rzPn36RP0SekFbW1uH+Hft2sUll1zCli1bACgpKWHmzJn87W9/Y8WKFdTV1VFSUsLLL7/M/fffzz/+8Y/Qeg899BB//etfee211wC44IIL+M53vsNXv/pVxo0bxzXXXMPVV19NTk4Os2bNwhhDSUkJGzZsCO3jxRdf5IorrmDjxo3cc889PPzwwxxxxBGUlZWxePFiZsyYwfXXX09mZiY6AJKYAAANeklEQVSPP/44AHfeeSeLFi06JMGFl607GhsbO33fk0FtbW3Sx5gsJFjlT+hBRZqB140xF4ct/xPwFSC3i+QVaZ//As4EiowxjZ2tO3r0aLN27dqor1dUVHDsscd25/BJRYeBjswL72t5eXmHzr2pRkSWGmMmdr1m19w6bdwNRPoE9gLqu5u4AhYHtj8unsCUUt7gVvJaDgyPsHwEVn+vqEQkR0TyI7zUFnhMjy80pZQXuJW8XgCOFJHhwQUiMhA4Fni+/YoiMlBE2sd5JfBghH1OAJqwrlgqpVKcW8nraawa1s9FJCOQnO7Hutr42+BKInI6sA2YE7b9l0XkpHbrXQlcAvwilg6uSinvc+VqozGmWUQmY90etBqrh/1K4Jyw5FMLHAC2t1s2D3gA+I2I+IC+wD7gemPM3ETEr5Ryn2v3NhpjdmJdWexsnY+BgrBlO4EfB36UUocpHRJHKeVJmryUUp6kyUsp5UmavJRSnqTJSynlSZq8lFKepMlLdfDII4/w4osvJvSYLS0t/PnPf2bKlClMmDCB4447jokTJ/LHP/6RSAMHLF26lLPPPpvjjz+e0aNHc8stt9DY2Om9+CoFafJSHbiRvJYuXcpVV13Ftddey9KlS1m1ahW33XYbX/va10LTqwWtX7+eSZMmcdlll7Fy5UoWL17M66+/zrXXXpvQmJX7NHmppHDaaafx5S9/OfT8iiuu4IwzzuDRRx/tUPv62c9+RkFBAd/97ncB6Nu3L3fddRd/+ctf+OCDDxIet3KPJq8U9/LLL1NaWoqIcOeddzJ79mwmTJjA0KFDueOOO0LrbdmyhdLSUrZt2xbaprS0lLfecn4yplNOOYX58+cfsnzw4MHU1dXR0tICQGtrK6+++ipnn312h3HwzznnHACef/75Q/ahUpfO25jipk+fzvTp0xERnnnmGZ5//nl+/vOf88Ybb3D++edz9tlnM2XKFIYNG8ayZcsYPnw4ZWVlPP30013ue8mSJVx33XVdrjdx4sTQ8M+RiEhoPPz21q1bx6mnnkpmZiZgTZFWV1cXGn46qLCwkF69erF8+fIuY1GpQ5NXrO52buqxbrn7QI83LS0tZcKECQBMmTKF/Px8ysvLmTJlSo/2N3HiRJYtW9bjeDrz/vvvs3z58g41st27dwNEHEm1d+/e7Nmzx5FYVHLS08bDyKhRozo879evn+2Ty9qhtraWr3/96/zkJz/hrLPOimkbN4YzV+7Smles4qjxJItIk8u2tbVFWdsdzc3NXH755UyZMoXbb7+9w2v9+/cHiDgBR01NDYWFhQmJUSUHTV6qx+xq8wpqbm7msssuY+zYsTz44KGD5R511FHk5eWxadOmDsv37NlDTU0NJSUlMceuvE+Tl+rA5/OFTsE+++wzKisrOe200yKua2ebV7DGNXLkSB5++OHQ8m9+85vcfffdDBo0iIyMDKZOncqCBQswxoSuOAbbxS677DJbYlHeoMlLdTBixAi2bt0KwNy5c9m+fXvU5GWX5uZmrrjiCjZs2MCVV17Js88+G3pt4cKFNDU1hZ7/8Ic/5Oyzz+bXv/41N954IwcOHODee+/lS1/6EieffLKjcaokY4w57H5GjRplOrN69epOX0921dXVod8XLlxoxo8fbwAzcOBAc8MNN5h9+/aZ8ePHG5/PZ/r162fOPffc0PrvvPOOGTNmjDn++OPNKaecYtauXet4vC+99JLBGgo84s/GjRs7lO2DDz4wZ511lhk7dqwZOXKkuemmm0xDQ0OXx/HC+zp//ny3Q3AUsMTY9D3WmleKO/PMMyOe2kU73TvttNOoqKhwOqwOpk+f3q2rhRMnTmTBggUORqS8QLtKKKU8SZOXUsqTNHkppTxJk5dSypM0eSmlPEmTl1LKkzR5RdGdS/cq+en7mXo0eUXg8/loaGhwOwxlo4aGhohjhinv0uQVQVFREZWVldTX1+t/bI8zxlBfX09lZSVFRUVuh6NspD3sI+jduzcA27ZtCw1B7CWNjY1kZ2e7HYYjelI2n8/HwIEDQ++rSg2avKLo3bu3Zz/s5eXlnHDCCW6H4YhULpvqHj1tVEp5kmvJS0SKRORPIrI28POciAyNcVufiPxYRNaIyEoReVdEznA6ZqVU8nAleYlIJvAmkAkcB4wF6oD5IpIfwy4eA64EzjTGHA/8AXhTREodClkplWTcqnl9FSgBZhtjWo0xbcBs4CjgW51tKCKjgZnA/caYXQDGmCeBDcB9jkatlEoabiWvy4HNxpgNwQXGmB3A6sBrnbkUECB8ltK3gSkx1tyUUh7nVvIqATZGWL4RGBfDtn5gc4RtM7BOQZVSKc6trhL9gaURllcDuSKSY4yJ1sW9P1AfONUM3xYg4vxXIjIT63QToElEVnYzZi/pD+x2OwiHpHLZIPXLN9quHSVbPy9xaltjzFxgLoCILDHGTIzjWEktlcuXymWDw6N8du3LrdPG3cChc7Zby+o7qXUFt80VkfQI2wLonO9KHQbcSl7LgeERlo8AVsSwbRowLMK2rUBiZ49QSrnCreT1AnCkiAwPLhCRgcCxwPPtVxSRgSLSPs5/YE2JVRa2z0nAG8aYQ+eCP9Tc7ofsKalcvlQuG2j5YiZujJoQ6KS6BKuWdBXW1cPfA2cAJxhjagPrnQ4sBOYaY77VbvvHsZLV6caY3SIyA5gDnGqMsWcKZ6VUUnOl5mWMaQYmA21YfbsqgN7AOcHEFVALHAC2h+3iRuDvwDuBq4bfAKZo4lLq8OFKzUupSERkEPAUcL4xJp4rz0knlcvmlpQZVSLVb/SOs3ybRGRZhJ/znI47ViJyKfAecHQPt58lIqtFZLmIfCgil9gbYc/FUzYRKQ+UK/y9u8b+SLtPREpF5AkRWSoiHwdi/ZWIDIhh2/i+d8YYz/9g3eD9MdapZAaQDvwR+ATIj2H7x4F1wIDA8+uABqDU7bLZVL5NbpchhhgXAyOBp62PZbe2vQ2rC83RgeeTgRZgqtvlsqFs5cBwt8vQSXxrsC6y5QWeDwksWwfkdLFtXN871wtv0x/wG1hXII9qt+wIrDa1H3Sx7WisCwYzwpavAv7ldtniLV9g3U1ulyGGGDMCj936ggN9sUYkuTds+b+AVW6XK56yBbbxQvI6JmzZ1wOf18s72S7u712qnDam+o3e8ZTPE4wxrT3c9AIgl8jv31gRGRNXYDaIo2xeUGKMWR+2bFvgsV8n28X9vUuV5JXqN3rHUz4AROQXIrJERNaJyBsiMt3WCN1TEngM//tsDHvdy24SkfcDbUMLReRatwMKMlbPgXCjsGpeCzvZNO7vXaokr/5ApM6poRu9u9i22zd6J1g85QOoAj4CTsca/PEl4CUR+Y6tUbqjf+Ax/O+TTO9fPPYD67H6NR4H/Ar4rYj80tWoogjctjcD+L0xZl0nq8b9vUu2G7Pt5tiN3kkiphiNMSeHLZojIhcCPxWRJ40xjfaH5jovvH9dMsaEXzV9TkQmAd8XkV8ZY8JrLm67E+s2ve/3cPuY37dUqXml+o3e8ZQvmsWB7Y+LJ7AkEBw+Jvzvk0zvn90WY313T3I7kPYCp7NfxLrKW9vF6nF/71IleaX6jd49Lp+I5ERp/AxW18M/PF6zPPA4PGz5iLDXPUdEMkWkT4SXku69E5H/AW7GukumKoZN4v7epUrycvtGb6fFU74rgQcj7HMC0IR1xdIzRKQwcG9s0GtAPZHfv9XGmDWJii1eEcp2GvC3CKtOCDx+5HxUXRORq7HmoDgvcBUcEbkoMABocB37v3du9xOxqa9JJlYm/ytWO14a1q0YHTpxYjVYtwG/Ddv+cWAt0D/wfAbJ10m1R+UDvobVCHpSu2VXYl3puTdRZehGWZ8mSl8orP/KjcC8sOW3AbsI9IMDziOJOqn2tGyBL3YrMC1sWR3w/9wuTyCeqwLflVuAq9v9/A6420T5XAaWx/W9S4kGe2NMs4hMBh7GqkkYYCXdu9H7f7Fu9G7BunKVNDd6x1m+ecADwG9ExIfVqXMfcL2xRpdNCiLyAFbP+OLA8+Df/mRz8HJ8A7CXg/2IADDG3C8ijcArItKK9UX5gjFmXkKC70IcZfsQuBX4oYj8FMgDmoGfYL2nyeAxIJvI8dwTeHTke6c3ZiulPClV2ryUUocZTV5KKU/S5KWU8iRNXkopT9LkpZTyJE1eSilP0uSllPIkTV5KKU/S5KWU8iRNXkopT9LkpZTyJE1eKqkF5qqsFhG/iLwVWDZHRPaJyEYRuc7tGJU79MZslfRE5AtY41p9wxjzpIgcCfwTOM10PWKnSlGavJQniMgLWON0lQJ/AH5qjHnD3aiUmzR5KU8QkSOwxjJrA14xxiTN9F/KHdrmpTzBWMML34M1ZVb4RKXqMKQ1L+UJgfHPy4EcrBFJjzPG7O50I5XStOalvOJ7WFN+XYI17PCj7oaj3KY1L5X0RORo4Dmsq4sNIvJNrMkbLjbGvOJudMotWvNSSU1E7gP+AxyBNbsMwA2Bxz+JyHOuBKZcpzUvpZQnac1LKeVJmryUUp6kyUsp5UmavJRSnqTJSynlSZq8lFKepMlLKeVJmryUUp6kyUsp5UmavJRSnvT/AXOngZpjWceFAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "linear_convection_cfl(85)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "linear_convection_cfl(121)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that as the number of points `nx` increases, the wave convects a shorter and shorter distance. The number of time iterations we have advanced the solution to is held constant at `nt = 20`, but depending on the value of `nx` and the corresponding values of `dx` and `dt`, a shorter time window is being examined overall. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/02_spacetime/02_03_1DDiffusion.ipynb b/2-finite-difference-method/lessons/02_spacetime/02_03_1DDiffusion.ipynb new file mode 100644 index 0000000..7a9bd36 --- /dev/null +++ b/2-finite-difference-method/lessons/02_spacetime/02_03_1DDiffusion.ipynb @@ -0,0 +1,939 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth, C. Cooper. Based on [CFDPython](https://github.com/barbagroup/CFDPython), (c)2013 L.A. Barba, also under CC-BY license." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Space & Time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1-D Diffusion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome back! This is the third Jupyter Notebook of the series *Space and Time — Introduction of Finite-difference solutions of PDEs*, the second module of [\"Practical Numerical Methods with Python\"](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about). \n", + "\n", + "In the previous Jupyter notebooks of this series, we studied the numerical solution of the linear and non-linear convection equations using the finite-difference method, and learned about the CFL condition. Now, we will look at the one-dimensional diffusion equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial u}{\\partial t}= \\nu \\frac{\\partial^2 u}{\\partial x^2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $\\nu$ is a constant known as the *diffusion coefficient*.\n", + "\n", + "The first thing you should notice is that this equation has a second-order derivative. We first need to learn what to do with it!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Discretizing 2nd-order derivatives" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second-order derivative can be represented geometrically as the line tangent to the curve given by the first derivative. We will discretize the second-order derivative with a Central Difference scheme: a combination of forward difference and backward difference of the first derivative. Consider the Taylor expansion of $u_{i+1}$ and $u_{i-1}$ around $u_i$:\n", + "\n", + "$$\n", + "u_{i+1} = u_i + \\Delta x \\frac{\\partial u}{\\partial x}\\big|_i + \\frac{\\Delta x^2}{2!} \\frac{\\partial ^2 u}{\\partial x^2}\\big|_i + \\frac{\\Delta x^3}{3!} \\frac{\\partial ^3 u}{\\partial x^3}\\big|_i + {\\mathcal O}(\\Delta x^4)\n", + "$$\n", + "\n", + "$$\n", + "u_{i-1} = u_i - \\Delta x \\frac{\\partial u}{\\partial x}\\big|_i + \\frac{\\Delta x^2}{2!} \\frac{\\partial ^2 u}{\\partial x^2}\\big|_i - \\frac{\\Delta x^3}{3!} \\frac{\\partial ^3 u}{\\partial x^3}\\big|_i + {\\mathcal O}(\\Delta x^4)\n", + "$$\n", + "\n", + "If we add these two expansions, the odd-numbered derivatives will cancel out. Neglecting any terms of ${\\mathcal O}(\\Delta x^4)$ or higher (and really, those are very small), we can rearrange the sum of these two expansions to solve for the second-derivative. \n", + "\n", + "$$\n", + "u_{i+1} + u_{i-1} = 2u_i+\\Delta x^2 \\frac{\\partial ^2 u}{\\partial x^2}\\big|_i + {\\mathcal O}(\\Delta x^4)\n", + "$$\n", + "\n", + "And finally:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial ^2 u}{\\partial x^2}=\\frac{u_{i+1}-2u_{i}+u_{i-1}}{\\Delta x^2} + {\\mathcal O}(\\Delta x^2)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The central difference approximation of the 2nd-order derivative is 2nd-order accurate." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Back to diffusion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now write the discretized version of the diffusion equation in 1D:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{u_{i}^{n+1}-u_{i}^{n}}{\\Delta t}=\\nu\\frac{u_{i+1}^{n}-2u_{i}^{n}+u_{i-1}^{n}}{\\Delta x^2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "As before, we notice that once we have an initial condition, the only unknown is $u_{i}^{n+1}$, so we re-arrange the equation to isolate this term:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u_{i}^{n+1}=u_{i}^{n}+\\frac{\\nu\\Delta t}{\\Delta x^2}(u_{i+1}^{n}-2u_{i}^{n}+u_{i-1}^{n})\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This discrete equation allows us to write a program that advances a solution in time—but we need an initial condition. Let's continue using our favorite: the hat function. So, at $t=0$, $u=2$ in the interval $0.5\\le x\\le 1$ and $u=1$ everywhere else." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Stability of the diffusion equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The diffusion equation is not free of stability constraints. Just like the linear and non-linear convection equations, there are a set of discretization parameters $\\Delta x$ and $\\Delta t$ that will make the numerical solution blow up. For the diffusion equation and the discretization used here, the stability condition for diffusion is\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nu \\frac{\\Delta t}{\\Delta x^2} \\leq \\frac{1}{2}\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### And solve!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " We are ready to number-crunch!\n", + "\n", + "The next two code cells initialize the problem by loading the needed libraries, then defining the solution parameters and initial condition. This time, we don't let the user choose just *any* $\\Delta t$, though; we have decided this is not safe: people just like to blow things up. Instead, the code calculates a value of $\\Delta t$ that will be in the stable range, according to the spatial discretization chosen! You can now experiment with different solution parameters to see how the numerical solution changes, but it won't blow up." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "nx = 41 # number spatial grid points\n", + "L = 2.0 # length of the domain\n", + "dx = L / (nx - 1) # spatial grid size\n", + "nu = 0.3 # viscosity\n", + "sigma = 0.2 # CFL limit\n", + "dt = sigma * dx**2 / nu # time-step size\n", + "nt = 20 # number of time steps to compute\n", + "\n", + "# Get the grid point coordinates.\n", + "x = numpy.linspace(0.0, L, num=nx)\n", + "\n", + "# Set the initial conditions.\n", + "u0 = numpy.ones(nx)\n", + "mask = numpy.where(numpy.logical_and(x >= 0.5, x <= 1.0))\n", + "u0[mask] = 2.0" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Integrate in time.\n", + "u = u0.copy()\n", + "for n in range(nt):\n", + " u[1:-1] = u[1:-1] + nu * dt / dx**2 * (u[2:] - 2 * u[1:-1] + u[:-2])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the solution after nt time steps\n", + "# along with the initial conditions.\n", + "pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('u')\n", + "pyplot.grid()\n", + "pyplot.plot(x, u0, label='Initial',\n", + " color='C0', linestyle='--', linewidth=2)\n", + "pyplot.plot(x, u, label='nt = {}'.format(nt),\n", + " color='C1', linestyle='-', linewidth=2)\n", + "pyplot.legend(loc='upper right')\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.5, 2.5);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Animations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looking at before-and-after plots of the wave in motion is helpful, but it's even better if we can see it changing! \n", + "\n", + "First, let's import the `animation` module of `matplotlib` as well as a special IPython display method called `HTML` (more on this in a bit)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Note\n", + "\n", + "You will also have to install a video encoder/decoder named `ffmpeg`.\n", + "\n", + "If you use Linux or OSX, you can install ffmpeg using conda:\n", + "```\n", + "conda install -c conda-forge ffmpeg\n", + "```\n", + "\n", + "If you use Windows, installation instructions can be found [here](http://adaptivesamples.com/how-to-install-ffmpeg-on-windows/)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import animation\n", + "from IPython.display import HTML" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are going to create an animation.\n", + "This takes a few steps, but it's actually not hard to do!\n", + "\n", + "First, we define a function, called `diffusion`, that computes the numerical solution of the 1D diffusion equation over the time steps.\n", + "(The function returns a list with `nt` elements, each one being a Numpy array.)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def diffusion(u0, sigma=0.5, nt=20):\n", + " \"\"\"\n", + " Computes the numerical solution of the 1D diffusion equation\n", + " over the time steps.\n", + " \n", + " Parameters\n", + " ----------\n", + " u0 : numpy.ndarray\n", + " The initial conditions as a 1D array of floats.\n", + " sigma : float, optional\n", + " The value of nu * dt / dx^2;\n", + " default: 0.5.\n", + " nt : integer, optional\n", + " The number of time steps to compute;\n", + " default: 20.\n", + " \n", + " Returns\n", + " -------\n", + " u_hist : list of numpy.ndarray objects\n", + " The history of the numerical solution.\n", + " \"\"\"\n", + " u_hist = [u0.copy()]\n", + " u = u0.copy()\n", + " for n in range(nt):\n", + " u[1:-1] = u[1:-1] + sigma * (u[2:] - 2 * u[1:-1] + u[:-2])\n", + " u_hist.append(u.copy())\n", + " return u_hist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now call the function to store the history of the solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute the history of the numerical solution.\n", + "u_hist = diffusion(u0, sigma=sigma, nt=nt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we create a Matplotlib figure that we want to animate.\n", + "For now, the figure contains the initial solution (our top-hat function)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('u')\n", + "pyplot.grid()\n", + "line = pyplot.plot(x, u0,\n", + " color='C0', linestyle='-', linewidth=2)[0]\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.5, 2.5)\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**: `pyplot.plot()` can (optionally) return several values. Since we're only creating one line, we ask it for the \"zeroth\" (and only...) line by adding `[0]` after the `pyplot.plot()` call." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that our figure is initialized, we define a function `update_plot` to update the data of the line plot based on the time-step index." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def update_plot(n, u_hist):\n", + " \"\"\"\n", + " Update the line y-data of the Matplotlib figure.\n", + " \n", + " Parameters\n", + " ----------\n", + " n : integer\n", + " The time-step index.\n", + " u_hist : list of numpy.ndarray objects\n", + " The history of the numerical solution.\n", + " \"\"\"\n", + " fig.suptitle('Time step {:0>2}'.format(n))\n", + " line.set_ydata(u_hist[n])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we create an `animation.FuncAnimation` object with the following arguments:\n", + "\n", + "* `fig`: the name of our figure,\n", + "* `diffusion`: the name of our solver function,\n", + "* `frames`: the number of frames to dra (which we set equal to `nt`),\n", + "* `fargs`: extra arguments to pass to the function `diffusion`,\n", + "* `interval`: the number of milliseconds each frame appears for." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Create an animation.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(u_hist,),\n", + " interval=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ok! Time to display the animation.\n", + "We use the `HTML` display method that we imported above and the `to_html5_video` method of the animation object to make it web compatible." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/02_spacetime/02_04_1DBurgers.ipynb b/2-finite-difference-method/lessons/02_spacetime/02_04_1DBurgers.ipynb new file mode 100644 index 0000000..42ec883 --- /dev/null +++ b/2-finite-difference-method/lessons/02_spacetime/02_04_1DBurgers.ipynb @@ -0,0 +1,2868 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth, C. Cooper. Based on [CFDPython](https://github.com/barbagroup/CFDPython), (c)2013 L.A. Barba, also under CC-BY license." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Space & Time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Burgers' Equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hi there! We have reached the final lesson of the series *Space and Time — Introduction to Finite-difference solutions of PDEs*, the second module of [\"Practical Numerical Methods with Python\"](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about).\n", + "\n", + "We have learned about the finite-difference solution for the linear and non-linear convection equations and the diffusion equation. It's time to combine all these into one: *Burgers' equation*. The wonders of *code reuse*!\n", + "\n", + "Before you continue, make sure you have completed the previous lessons of this series, it will make your life easier. You should have written your own versions of the codes in separate, clean Jupyter Notebooks or Python scripts." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can read about Burgers' Equation on its [wikipedia page](http://en.wikipedia.org/wiki/Burgers'_equation).\n", + "Burgers' equation in one spatial dimension looks like this:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial u}{\\partial t} + u \\frac{\\partial u}{\\partial x} = \\nu \\frac{\\partial ^2u}{\\partial x^2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "As you can see, it is a combination of non-linear convection and diffusion. It is surprising how much you learn from this neat little equation! \n", + "\n", + "We can discretize it using the methods we've already detailed in the previous notebooks of this module. Using forward difference for time, backward difference for space and our 2nd-order method for the second derivatives yields:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{u_i^{n+1}-u_i^n}{\\Delta t} + u_i^n \\frac{u_i^n - u_{i-1}^n}{\\Delta x} = \\nu \\frac{u_{i+1}^n - 2u_i^n + u_{i-1}^n}{\\Delta x^2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "As before, once we have an initial condition, the only unknown is $u_i^{n+1}$. We will step in time as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u_i^{n+1} = u_i^n - u_i^n \\frac{\\Delta t}{\\Delta x} (u_i^n - u_{i-1}^n) + \\nu \\frac{\\Delta t}{\\Delta x^2}(u_{i+1}^n - 2u_i^n + u_{i-1}^n)\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initial and Boundary Conditions\n", + "\n", + "To examine some interesting properties of Burgers' equation, it is helpful to use different initial and boundary conditions than we've been using for previous steps. \n", + "\n", + "The initial condition for this problem is going to be:\n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "u &=& -\\frac{2 \\nu}{\\phi} \\frac{\\partial \\phi}{\\partial x} + 4 \\\\\\\n", + "\\phi(t=0) = \\phi_0 &=& \\exp \\bigg(\\frac{-x^2}{4 \\nu} \\bigg) + \\exp \\bigg(\\frac{-(x-2 \\pi)^2}{4 \\nu} \\bigg)\n", + "\\end{eqnarray}\n", + "$$\n", + "\n", + "This has an analytical solution, given by:\n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "u &=& -\\frac{2 \\nu}{\\phi} \\frac{\\partial \\phi}{\\partial x} + 4 \\\\\\\n", + "\\phi &=& \\exp \\bigg(\\frac{-(x-4t)^2}{4 \\nu (t+1)} \\bigg) + \\exp \\bigg(\\frac{-(x-4t -2 \\pi)^2}{4 \\nu(t+1)} \\bigg)\n", + "\\end{eqnarray}\n", + "$$\n", + "\n", + "The boundary condition will be:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u(0) = u(2\\pi)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This is called a *periodic* boundary condition. Pay attention! This will cause you a bit of headache if you don't tread carefully." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Saving Time with SymPy\n", + "\n", + "\n", + "The initial condition we're using for Burgers' Equation can be a bit of a pain to evaluate by hand. The derivative $\\frac{\\partial \\phi}{\\partial x}$ isn't too terribly difficult, but it would be easy to drop a sign or forget a factor of $x$ somewhere, so we're going to use SymPy to help us out. \n", + "\n", + "[SymPy](http://sympy.org/en/) is the symbolic math library for Python. It has a lot of the same symbolic math functionality as Mathematica with the added benefit that we can easily translate its results back into our Python calculations (it is also free and open source). \n", + "\n", + "Start by loading the SymPy library, together with our favorite library, NumPy." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "import sympy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We're also going to tell SymPy that we want all of its output to be rendered using $\\LaTeX$. This will make our Notebook beautiful!" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "sympy.init_printing()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Start by setting up symbolic variables for the three variables in our initial condition. It's important to recognize that once we've defined these symbolic variables, they function differently than \"regular\" Python variables. \n", + "\n", + "If we type `x` into a code block, we'll get an error:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'x' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'x' is not defined" + ] + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`x` is not defined, so this shouldn't be a surprise. Now, let's set up `x` as a *symbolic* variable:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "x = sympy.symbols('x')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's see what happens when we type `x` into a code cell:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAsAAAAJCAYAAADkZNYtAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAwUlEQVQYGVWQ3Q3CMAyE04oBKrEBbFCJDWADJDaADUB9St+QGKGMwAjtBghG6AZI2SB8l8b8WDqf7Vxd20WM0cnatq2gfUqcW8EnsAA1mINXiTNhwwcXgVKfUed8S76b4WQNOKdocktIXbtcO8Cj0xje+0psIO8Fy41tjJA7GK0JNMqfJfFvhRm1kGyY6OvTzAi0wADrD+rqiJ9iGfER6koCPd5AEsEb8DHetWiAQ6HlSK7gnhW6gO6tizxUQ5iu8gZXOlF/Vp9rRgAAAABJRU5ErkJggg==\n", + "text/latex": [ + "$\\displaystyle x$" + ], + "text/plain": [ + "x" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The value of `x` is $x$. Sympy is also referred to as a computer algebra system -- normally the value of `5*x` will return the product of `5` and whatever value `x` is pointing to. But, if we define `x` as a symbol, then something else happens:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABQAAAAOCAYAAAAvxDzwAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABZklEQVQ4Ea2U303DQAyH04oBKtigbFCJDWADEBvABqA+JW9Vu0HDBrQbtBtAO0I2ALJB+L7rXSB5ACph6Xf+c7brs50OmqbJiqLYZVm2BM/INZgg34MN8hr+ZxrEhB9EjHpRC5I99my/qifRo4JvwRi8gDXJtB1PVpjn+Ur+HxgeX8LPEenJGU+8i6728hwsse2/h6N7l/wukO2xbXKIZ+AtVaijEy7BAnkOdsiX8EAx2dT76LPhQkyifo18GyrEcBWi4oFeAYfkKlmtNAWzIB0O7VZXRptrVqUKo63DnPKYxAZJM+T6IIbTZ26TzQJANeRYARe7Tyk4JMQn6cnPdvjkDllh26fOzdeiv/bsGcmtTrItHbKHDsP398kf2qfK4DY9PTEUga3dAuQH7ksrnKPY/JbQXY1TcKMR3QQrEBLB+0O0Lf4H1Olb1uBO2Sfld3Ud4CYcwZ6An6XkZP1RJx36j0+Y9icZucR0ZBkKdgAAAABJRU5ErkJggg==\n", + "text/latex": [ + "$\\displaystyle 5 x$" + ], + "text/plain": [ + "5⋅x" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "5 * x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This will let us manipulate an equation with unknowns using Python! Let's start by defining symbols for $x$, $\\nu$ and $t$ and then type out the full equation for $\\phi$. We should get a nicely rendered version of our $\\phi$ equation." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/latex": [ + "$\\displaystyle e^{- \\frac{\\left(- 4 t + x - 2 \\pi\\right)^{2}}{4 \\nu \\left(t + 1\\right)}} + e^{- \\frac{\\left(- 4 t + x\\right)^{2}}{4 \\nu \\left(t + 1\\right)}}$" + ], + "text/plain": [ + " 2 2 \n", + " -(-4⋅t + x - 2⋅π) -(-4⋅t + x) \n", + " ─────────────────── ─────────────\n", + " 4⋅ν⋅(t + 1) 4⋅ν⋅(t + 1) \n", + "ℯ + ℯ " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x, nu, t = sympy.symbols('x nu t')\n", + "phi = (sympy.exp(-(x - 4 * t)**2 / (4 * nu * (t + 1))) +\n", + " sympy.exp(-(x - 4 * t - 2 * sympy.pi)**2 / (4 * nu * (t + 1))))\n", + "phi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It's maybe a little small, but that looks right. Now to evaluate our partial derivative $\\frac{\\partial \\phi}{\\partial x}$ is a trivial task. To take a derivative with respect to $x$, we can just use:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/latex": [ + "$\\displaystyle - \\frac{\\left(- 8 t + 2 x\\right) e^{- \\frac{\\left(- 4 t + x\\right)^{2}}{4 \\nu \\left(t + 1\\right)}}}{4 \\nu \\left(t + 1\\right)} - \\frac{\\left(- 8 t + 2 x - 4 \\pi\\right) e^{- \\frac{\\left(- 4 t + x - 2 \\pi\\right)^{2}}{4 \\nu \\left(t + 1\\right)}}}{4 \\nu \\left(t + 1\\right)}$" + ], + "text/plain": [ + " 2 2 \n", + " -(-4⋅t + x) -(-4⋅t + x - 2⋅π) \n", + " ───────────── ───────────────────\n", + " 4⋅ν⋅(t + 1) 4⋅ν⋅(t + 1) \n", + " (-8⋅t + 2⋅x)⋅ℯ (-8⋅t + 2⋅x - 4⋅π)⋅ℯ \n", + "- ─────────────────────────── - ───────────────────────────────────────\n", + " 4⋅ν⋅(t + 1) 4⋅ν⋅(t + 1) " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "phiprime = phi.diff(x)\n", + "phiprime" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want to see the non-rendered version, just use the Python print command." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-(-8*t + 2*x)*exp(-(-4*t + x)**2/(4*nu*(t + 1)))/(4*nu*(t + 1)) - (-8*t + 2*x - 4*pi)*exp(-(-4*t + x - 2*pi)**2/(4*nu*(t + 1)))/(4*nu*(t + 1))\n" + ] + } + ], + "source": [ + "print(phiprime)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now what?\n", + "\n", + "\n", + "Now that we have the Pythonic version of our derivative, we can finish writing out the full initial condition equation and then translate it into a usable Python expression. For this, we'll use the *lambdify* function, which takes a SymPy symbolic equation and turns it into a callable function. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2*nu*(-(-8*t + 2*x)*exp(-(-4*t + x)**2/(4*nu*(t + 1)))/(4*nu*(t + 1)) - (-8*t + 2*x - 4*pi)*exp(-(-4*t + x - 2*pi)**2/(4*nu*(t + 1)))/(4*nu*(t + 1)))/(exp(-(-4*t + x - 2*pi)**2/(4*nu*(t + 1))) + exp(-(-4*t + x)**2/(4*nu*(t + 1)))) + 4\n" + ] + } + ], + "source": [ + "from sympy.utilities.lambdify import lambdify\n", + "\n", + "u = -2 * nu * (phiprime / phi) + 4\n", + "print(u)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lambdify\n", + "\n", + "To lambdify this expression into a usable function, we tell lambdify which variables to request and the function we want to plug them into." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of u at t=1, x=4, nu=3 is 3.49170664206445\n" + ] + } + ], + "source": [ + "u_lamb = lambdify((t, x, nu), u)\n", + "print('The value of u at t=1, x=4, nu=3 is {}'.format(u_lamb(1, 4, 3)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Back to Burgers' Equation\n", + "\n", + "Now that we have the initial conditions set up, we can proceed and finish setting up the problem. We can generate the plot of the initial condition using our lambdify-ed function." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "nx = 101 # number of spatial grid points\n", + "L = 2.0 * numpy.pi # length of the domain\n", + "dx = L / (nx - 1) # spatial grid size\n", + "nu = 0.07 # viscosity\n", + "nt = 100 # number of time steps to compute\n", + "sigma = 0.1 # CFL limit\n", + "dt = sigma * dx**2 / nu # time-step size\n", + "\n", + "# Discretize the domain.\n", + "x = numpy.linspace(0.0, L, num=nx)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have a function `u_lamb` but we need to create an array `u0` with our initial conditions. `u_lamb` will return the value for any given time $t$, position $x$ and $nu$. We can use a `for`-loop to cycle through values of `x` to generate the `u0` array. That code would look something like this:\n", + "\n", + "```Python\n", + "u0 = numpy.empty(nx)\n", + "\n", + "for i, x0 in enumerate(x):\n", + " u0[i] = u_lamb(t, x0, nu)\n", + "```\n", + "\n", + "But there's a cleaner, more beautiful way to do this -- *list comprehension*. \n", + "\n", + "We can create a list of all of the appropriate `u` values by typing\n", + "\n", + "```Python\n", + "[u_lamb(t, x0, nu) for x0 in x]\n", + "```\n", + "\n", + "You can see that the syntax is similar to the `for`-loop, but it only takes one line. Using a list comprehension will create... a list. This is different from an *array*, but converting a list to an array is trivial using `numpy.asarray()`. \n", + "\n", + "With the list comprehension in place, the three lines of code above become one:\n", + "\n", + "```Python\n", + "u = numpy.asarray([u_lamb(t, x0, nu) for x0 in x])\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([4. , 4.06283185, 4.12566371, 4.18849556, 4.25132741,\n", + " 4.31415927, 4.37699112, 4.43982297, 4.50265482, 4.56548668,\n", + " 4.62831853, 4.69115038, 4.75398224, 4.81681409, 4.87964594,\n", + " 4.9424778 , 5.00530965, 5.0681415 , 5.13097336, 5.19380521,\n", + " 5.25663706, 5.31946891, 5.38230077, 5.44513262, 5.50796447,\n", + " 5.57079633, 5.63362818, 5.69646003, 5.75929189, 5.82212374,\n", + " 5.88495559, 5.94778745, 6.0106193 , 6.07345115, 6.136283 ,\n", + " 6.19911486, 6.26194671, 6.32477856, 6.38761042, 6.45044227,\n", + " 6.51327412, 6.57610598, 6.63893783, 6.70176967, 6.76460125,\n", + " 6.82742866, 6.89018589, 6.95176632, 6.99367964, 6.72527549,\n", + " 4. , 1.27472451, 1.00632036, 1.04823368, 1.10981411,\n", + " 1.17257134, 1.23539875, 1.29823033, 1.36106217, 1.42389402,\n", + " 1.48672588, 1.54955773, 1.61238958, 1.67522144, 1.73805329,\n", + " 1.80088514, 1.863717 , 1.92654885, 1.9893807 , 2.05221255,\n", + " 2.11504441, 2.17787626, 2.24070811, 2.30353997, 2.36637182,\n", + " 2.42920367, 2.49203553, 2.55486738, 2.61769923, 2.68053109,\n", + " 2.74336294, 2.80619479, 2.86902664, 2.9318585 , 2.99469035,\n", + " 3.0575222 , 3.12035406, 3.18318591, 3.24601776, 3.30884962,\n", + " 3.37168147, 3.43451332, 3.49734518, 3.56017703, 3.62300888,\n", + " 3.68584073, 3.74867259, 3.81150444, 3.87433629, 3.93716815,\n", + " 4. ])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Set initial conditions.\n", + "t = 0.0\n", + "u0 = numpy.array([u_lamb(t, xi, nu) for xi in x])\n", + "u0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have the initial conditions set up, we can plot it to see what $u(x,0)$ looks like:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEoCAYAAACkdq2MAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXxX9Z3v8dcnCSFAwh72JO6gIqAgSa1atGqtrftO0t6209o7nZkud9pHp+3UttO9ffTOTDud22v3O4ni2lqtjnvcEzYRFRAUSQIhhIAsAbJ/7h/nJIT4A35Zz+/3y/v5eOTxg/PbPslJ8s453/P9fszdERERiUda1AWIiEjyUGiIiEjcFBoiIhI3hYaIiMRNoSEiInFTaIiISNwUGtJrZrbWzHaamZtZi5nVmdk3+vmaT5rZG2Y2spfP+62ZbTWzqX1834+H9beYWcpcfx5+TnvDffSJHvddFt73yV6+5llm1mBm3xrQYiWpKDSk19x9HnBu+N+X3H2au3+/ny87GRgPpHffaGbfDn/xLTnK8yYBY4HMvrypu/8/d58GvNSX5yeq8HP6wlHuzgZygHE97wi/1uVHed6o8HkTBqJGSU4ZURcgEloIpLl7ay+fdy2Q6e7Ng1BTSnL3B8xstLs39fJ5y81sXG+fJ6lFoSEJwd3bgfY+PM8BBUYv9fUXvwJDdHpKBpSZ/Ud4Pt3NrNzMFoW3O82sysx+ZmZZ3R4/O3x8Y/fTUGaWbmZ1wJfDhz4QPq7OzL5hZqOPc97+Q2Z2l5m9bWY7zGyXmf3VzBYP4Od6iZk9bmb1YS0bzOwPZnZJj8eZmf1PM1sVPrbezF4wsxt7PO6r4eu0m9kWMzvFzB4Ot203s9+b2fgYdWSY2bfC5+w2s/Vm9hXAYjz21933T8/3Dv97XrevdZ2ZjTSz27vXFuN1M83sa+G41I7wc3zczC7u8bhefX90e16xmVWaWa2ZbTOzV8zsJ2Z22rH3kgw4d9eHPnr9AZwAOFB+lPsdeBsoAyYS/AL7dLj9xzEe/+3wviXxbO92/yfC+z/RY3s58AIwM/x/LnA/0AScE+N1ygkPXOL8/G8DOoCfAKPCbQuAt4A9PR77R6AFuCX8OmQAXwzr/k6M194CNAD3AbPCbR8mOBK7O8bjS8NaPkPwh+Ao4GvA67G+Nt32z3v23bH2abfatvTYNgJ4EtgDfDDcNgr4aVjX3/Tn+wMoDl/num7bLgL2At+O+mdhuH1EXoA+kvMjztBoAab12F4LbI7x+IEOjf8LLOyxbSzQBiyL8TpxhwYwMwyfTYD1uO+q7qEBXBfW97sYr/NM+MuwZ51bwuf03P4Swam4Ed22XRQ+9pEYr//sEIXG/wqfd3uP7UYQok3AjL5+fwAPALti1PId4PNR/ywMtw+dnpLBtNnd63psqwJmDfYbu/tn3X1Vj237CH4pzevny98IjAT+7OFvr24eA67v9v+PhbcPxHid+wl+sRbHuK+pZ/0EX7tMgqOmTp3v9VCM13gyxrbBEPNzDL82fyb4Wt0Q43nxfn/sACaa2X+aWdd97v4td/95vyqXXlNoyGCqj7GtmeB0xqAyszwz+1cze7X7+XmCo4TR/Xz5zvPo23re4e7N7v5Ut02zw9utMV6n8/lzYty3M8a2zgH/7pcXnxLe1sZ4fKxtg6Gvn2O83x+3A08AfwtUh2MbXzOz6X0pVvpHoSGDqSOKNw1/mawGbgI+RzCuMc2DuQs1A/EWA/zYWJMKe/u1601NUejz5+juO939MuAs4HsE80R+AGwys6sGrkSJh0JDUtFNBJMFf+HuL3pwOe9A2hDezux5R3jV1ywzyzzeY7tte7MftbwV3s6IcV+sbYOhs/5B+RzDr6m5++vufru7n0YwP2cE8Iu+vq70jUJDEl1jeDsCwMzmmNlPjvOczrkER/wla8ESJdMGoKZ7CU6jXGNmPf/CvwHYSHD1EARXNkHwS66nzm139qOWznGEq2Pcd2kfXu8A3U4PmdkXe142G0PMzzH82lxN8LW6rw+1dHqK4A+BLu7+Z4KrwzQ7fYgpNCTRvRbezg9vPw588DjPeYTg8s/Pm9nZAGaWA/yKYFC2X9y9Fvg8cDLww855BeEckJ8BP3D3veFj7ye4rPRjZnZTOGcjw8z+AbgY+L67r+xHLU8Dy4BLzew2M0szsywz+xpwah9e8jXgFDMbY8F6Xt8CxhznOT8nuPrsHzsDJvya/JDga/T58GvWH183s86xE8zso8Bc4L/6+brSW1FfvqWP5PsA1hIM1HZeNlkHfCO87/bw/93vOy/8qAu3eedzCAZR6wiOKBzYDazo8X4/IxjUrQOWA4sIBrPrCK7V9/C2rttzzgEeJZjv0AC8SnB5bhXBfIc6ggD6eIy6/j3Or8MlBAO0O8PnvQJ8OsbjjGAQdzXB4O9O4EXg5h6P+2T4Ou3darwZyAv/fSiscSfwq27PG0FwaXJV+PV7C/g+wVySrq8NQWD+Osb+ubnbay0Mv8YNBOM/Pwvr79yv3Wv7crfnjQS+Dqzr9jk+AVza43Ps1fdH+Jzzw7rXh98H24FVwN8D6VH/PAy3Dwt3SiTCAcvfAx9y90QfyBMRGfYiOz1lZtcCLxMcvh7rcSPM7LvhEg2vm9lLZnb+0FQpIiLdRTmm8U8EA3UvHudxvyA4RL/A3ecCvwOeMLMFg1yfiIj0EGVovN/dNx3rAeHA123Aj9x9J4C7/wbYTHDOVkREhlBkoeHubXE87FqCQbhnemx/GrjMzLIHvDARETmqRO+nMY/gWvvqHtvfIaj9DIIrPY5gZrcRHKGQlZW1MD8/f5DLlP7q6OggLU1XgCcD7avk0J/9tHHjxgZ3z411X6KHxmTgoL93Ru++8HZSrCe5+x3AHQCzZ8/2N9/sz4RbGQrl5eUsWbIk6jIkDtpXyaE/+8nMqo52X7L+uaDLc0VEIpDoodEAjDaz9B7bc8LbXUNcj4jIsJboobGWoMa8HttPJGims37IKxIRGcYSPTT+RNi1rcf2i4DH3X3/kFckIjKMJXRouPubBAPaXzOzyQBm9imCWeTfiLI2EZHhKLKrp8zspwQzwvPD/68J71rs7i3dHvoPBCttvmhmrcB+4DJ3X4OIiAypyELD3b8S5+NagX8OP0REJEIJfXpKREQSi0JDRETiptAQEZG4KTRERCRuCg0REYmbQkNEROKm0BARkbgpNEREJG4KDRERiZtCQ0RE4qbQEBGRuCk0REQkbgoNERGJm0JDRETiptAQEZG4KTRERCRuCg0REYmbQkNEROKm0BARkbgpNEREJG4KDRERiZtCQ0RE4qbQEBGRuCk0REQkbgoNERGJm0JDRETiptAQEZG4KTRERCRuCg0REYmbQkNEROKW8KFhZovM7FEzW29mr5nZcjO7Meq6RESGo4QODTM7AXgKaADOcvezgN8B95jZlRGWJiIyLCV0aABXAGOB/+3ubQDu/itgH7A0ysJERIajRA+NtvA2o3ODmRlB3emRVCQiMowlemgsAzYA/2xm2WaWBnwdGAn8KtLKRESGIXP3qGs4JjObAfwe+ADQCOwFPuXuzx7jObcBtwHk5uYuvOeee4aiVOmHxsZGsrOzoy5D4qB9lRz6s58uuuiiVe6+KNZ9CR0aZjabYCD8EeCLQBNwE/BLoMTdHz3ea8yePdvffPPNQa1T+q+8vJwlS5ZEXYbEQfsqOfRnP5nZUUMj0U9PfRcYD3zB3Q+6e4e7LwOeA/5oZhnHfrqIiAykRA+Ns4Ct7n6ox/aNQC5w4tCXJCIyfCV6aNQD02McURQADrw79CWJiAxfiR4avyCYp/Ev4aW2mNlFwHXA3e7eEGVxIiLDTUKPCbj7fWZ2OfBPwDozawc6gG8AP4+0OBGRYSihQwPA3R8DHou6DhERSfzTUyIikkAUGiIiEjeFhoiIxE2hISIicVNoiIhI3BQaIiISN4WGiIjETaEhIiJxU2iIiEjcFBoiIhI3hYaIiMRNoSEiInFTaIgMkh37mti0Y3/UZYgMqIRf5VYkWXR0OBWbd/HUhnpe2NTAm2Fg/O4Ti7h4ztSIqxMZGAoNkX6q39/Efau2smx5DdW7D3Ztz0gz2jqc7z68nvNPySUzQwf2kvwUGiJ94O68/PYuyiqreeyNOto6HICZ40dx1YIZXHhqLvNmjePK/3iBzTsP8MeXtvCZC0+KuGqR/lNoiPTCnoMt3LdqK3dWVrO54QAAaQaXnjGVpYvzufC0XNLTrOvx3/zIGXzyDyv4+VObuPacmUzOHhlV6SIDQqEhchzuzpqaPZRWVPPw2lqa2zoAmDp2JLecm88ti/OYPm5UzOdeNGcKHzgtl2c37uRnj2/kh9edNZSliww4hYbIURxobuPBNbWUVVbxRu2+ru0XnDqZ4sICLjl9Chnpxx+n+OZHT+eFf2vg7hXVfKyogDNmjB3MskUGlUJDpIcNdfsoq6jmT69so7G5DYAJo0dw46I8li7O54TJY3r1eqdMyaGkMJ8/vlxFaWUVP7hWRxuSvBQaIkBTazuPvr6dsopqVla927V9UcEESooKuHzuNLJGpPf59YtOmsQfX65iV2PzQJQrEhmFhgxrWxoOcOfyau5dWcO7B1sByB6ZwXXnzGRpYT5zpg3MqaTsrOBHbX9T24C8nkhUFBoy7LS1d/Dk+h2UVVbz/KaGru1nzhhLcWEBVy+YwZiRA/ujkR2+XufpLpFkpdCQYWP73kMsW17DshXV7NgXnCYamZHGlfNnUFJUwPxZ4zCz47xK3+RkjQCgUUcakuQUGpLSOjqc599qoKyiiqc21NMeTsI7OXcMxYUFXH/OLMaNHjHodeSEp6f2KTQkySk0JCXtamzm3nASXufSHhlpxkfmTae4MJ/3nTRp0I4qYukMjcbm1iF7T5HBoNCQlOHurNjyLmWVVTz6Wh0t7cEkvJnjR3Hr4jxuOjePKTlZkdQ2akQ66WlGU2sHre0djIhjfodIIlJoSNLb19TKn1Zvo6yyio07GgEwg4vnTKGkKJ8PnDbliKU9omBmZI/MYO+hVhqb2pgwJjPSekT6SqEhSev1bXsprajiwTW1HGptB2By9khuOTePWxbnMWvC6IgrPFJnaOxXaEgSU2hIUjnU0s5Da2spq6ji1a17u7afd/IkigsLuOzMqQl76qdzXGO/xjUkiSk0JCm8Vb+fsspq7l+1tesKpLFZGdywMI/ionxOzs2OuMLjy9EEP0kBSREaZnY98AVgDDAB2A38u7v/V6SFyaBqaevgv9+oo6yiisp3dndtn583npLCfK6cP6NfS3sMNc3VkFSQ8KFhZl8CPgZc5e5bzWwE8Efgg4BCIwXV7D7YtbRHQ2MLAKMz07l6wUyKC/OZO3NcxBX2TeescJ2ekmSW0KFhZicAPwLOd/etAO7eamZfBmZEWJoMsA53nly3g7LKKso37sSDOXjMmZZDcWE+15w9s+sv9WTVNVdDRxqSxBI6NAiOMPa4+4ruG929FqiNpiQZSPX7mrh7RQ2/f/4Qu5tWApCZntY1CW9hwYQhnYQ3mLI1K1xSQKKHxnnAlnBM44tALsF4xm/c/XdHe5KZ3QbcBpCbm0t5efkQlCrxcnfW7+7g6epWXqlvpz08qpgy2rgobwTnz8wgJ3MPjVv28OyWSEsdUA21wam2dRs3U25bI66m7xobG/UzlQQGaz8lemjkAScAXwauBeqB64G7zGy6u38/1pPc/Q7gDoDZs2f7kiVLhqRYObYj+2s3AZCeZnzojCmcNWovn7vuYtIinoQ3mKoyt3D/pjeYOHUGS5bMjbqcPisvL0c/U4lvsPZToodGFsEVU19x97pw271mdgvwdTP7V3c/GF15cjzuzurqPZRVVvHw2u20hP21p43N4tbF+dx8bh7TxmVRXl6e0oEB3S+51UC4JK9ED4394e2aHttfAa4DzgBWDmlFEpfG5jYeXLON0opq1m8/3F/7wtNyKSnM5+I58fXXTiXqqSGpINFDYwOwAOj526U9vB1ev3WSwPrt+yirrOLPr9R2/XKcOCaTm8L+2vmTEmtpj6GkgXBJBYkeGg8BtwDzgBe6bZ8LHALeiKIoOVJTazuPvLadsspqVnXrr734hIkUF+Vz+dxpjMxInkl4g2WsJvdJCkj00Lib4Kqp75nZR9290cwuAG4A/sXdD0Rb3vD2TsMB7qys4t5VW9kT9tfOGZnBtefMpLiwgNnTciKuMLFocp+kgoQODXdvN7PLgR8Db5hZE9AM/L27/zra6oan1vYOnlq/g9KKal5463B/7bkzx1JSWMCV8we+v3aq0OQ+SQUJ/9Pt7ruBz0Rdx3BXu+cQy1bUsGx5NfX7g/7aWSPSuGr+DIoLC5g3iP21U0V2twUL3V1fL0lKCR8aEp2ODue5TTsprajm6Q07CNtrc8qUbJYuzh+y/tqpYmRGOpkZabS0ddDc1pFUiy2KdFJoyHs0NDZz78qt3Lm8iprdhwAYkW5cceY0SooKKDxxov5K7qOckRnsamthX1OrQkOSkkJDgGAS3vJ3dlNWWc2jr2+nNVzbY+b4USwtzOemRXnk5oyMuMrkl5OVwa4DLTQ2tTFF1wlIElJoDHN7D7Xyp9VbKausZlN90F87zeCS06dQXFjAhaflRt5fO5VkqxGTJDmFxjC1duseyiqq+curh/tr5+aM5OZFedxamM/M8aMirjA15YwM52poVrgkKYXGMHKwpY2HXq2ltKKa17Yd2V+7pKiAS89I3P7aqUJHGpLsFBrDwKYdYX/t1Vu7flmNGzWCGxfO4tbC5OivnSq0aKEkO4VGiursr11aUcXybv21z84fT0lhAR+ZN11X70QgR4sWSpJTaKSYzv7a96yoYdeBw/21rzk76K995ozk7K+dKjpb1ur0lCQrhUYKaGvv4Jk3d1JWWcWzPftrFxVwzYIZSd9fO1V0jmnoSEOS1YCGhpn9p7t/biBfU45uR9hf+67l1WzfG3TCy8xI46NnTae4KJ9z8lOnv3aq0JiGJLtehYaZffw4D7miH7VIHDo6nJfe3kVpRRVPrN9Be7i2x4mTx1BcGCztMWFMZsRVytF0rXSr01OSpHp7pPGHY9zn/ahDjuPdA2F/7eXVvNMQrAifnmZ8eO40igsLOO/kSSnfLjUV5OiSW0lyvQ2N9bz3aGIMMAdYCvxyIIqSQNBf+13KKqp5+LXD/bWnjzvcX3vq2KyIq5Te6Bxb0piGJKvehsbn3b0qxvZ1ZvYosAx4pv9lDW+NzW386ZVtlFVUsaEuaJNuBh84LZeSogIump077Pprp4rDp6c0piHJqVeh4e5PHeO+Q2Y2p/8lDV/ravdRWlnFg69s40BLsLTHpDGZ3Kj+2ilDjZgk2fV2IPzCWJuBCcA1QNNAFDWcNLW289e12ymtrOKV6j1d2xefOJHiQvXXTjWda09pTEOSVW9PT5UTe8DbgK1ASX8LGi4272zkzspq7lvdrb92VgbXnzOL4sJ8Tp2qdbNTUdc8jZY2OjpcFy9I0ultaLwNfLrHtnagHnjb3dsHpKoU1drewRPrdlBWWcWLb+3q2j5v1jiKC/O5cv4MRmdqvmUqS08zRmemc7ClnYOt7V1jHCLJorffsb9092cHpZIUtm3PIZYtr2bZihp2duuvffX8mSwtzGd+3viIK5ShlJOVwcGWdvY3tSo0JOn0diD83warkFTT3uE8tzFY2uPpDfVH9NcuLsznunNmMW6UlvYYjrJHZrCD5mAwXEuBSZLRnzkDrKGxuWtpj63vHu6v/ZG50ykpzGex+msPe51zNfZpMFySkEJjALg7le/sprSiisfeqOvqr503cRRLFxdw46JZTM5Wf20J5GjRQkliCo1+2HuolQfC/tpvHdFfeyrFRfl84NRcXR0j76FFCyWZKTT64NWaPZRVVvGXV2tpag2W9sjNGcmt5+Zx82L115Zj6xz81gQ/SUYKjTgdbGnjL2tqKas8sr/2+0+ZRElhAZeov7bESY2YJJkpNI5j4479lFVU8cDqbewPz0GPHx32116cz0nqry291LX+lMY0JAkpNGJobmvnv1+vo6yimuVbDvfXXlgwgeLCfK44S/21pe80piHJTKHRTfWuoL/2vSsP99ce09Vfu4AzZoyNuEJJBVq0UJJZ0oWGmT0PnA+c6O5b+vt6be0dPL2hnrLKap7bdLi/9unTx1JSlM/VC2Zq1q4MqGwtWihJLKl+G5rZ9QSB0W91e4P+2stW9OivPW86xYUFnJM/XpPwZFBonoYks6QJDTPLBH4IPEIfe5F3dDgvvt1AWUV1zP7aNyycxfjR6q8tg6tzpVsNhEsySprQAP4OWAlspJehsftAC/etquHOymq27DoIHO6vXVJUwPtOUn9tGTpjNRAuSSwpQsPMJgJfAc4DPtGb5+485BT98Kmu/tozuvXXnqL+2hKBzjENDYRLImpr7zjm/UkRGsDtQKm7b+ntOMOBVmdcewcXzc6luLCAi+ZMIV1HFRKhw5fcKjQkcXQf5z2WhA8NMzsFuAk4vRfPuQ24DSBnSh4/uWAUuaMPQv16nq9fP0iVSn80NjZSXl4edRlDwt0x4FBrO089/UzS/REznPZVMotnP3W4s25XB8/UtPJKfXtXC4djSfjQAH4C/Mjd9x73kSF3vwO4A2D27Nl+4xUXD1ZtMkDKy8tZsmRJ1GUMmZxnH2NfUxsLi96fdBdfDLd9layOtZ+OHOcNrh7NSDMunzuV4sICzv/x0V83oUPDzC4A5gI3R12LyEDKyRrBvqY29je1JV1oSHJyd1ZVvUtpRRWPvFZHS3vfxnkTOjSAS4F0YEW3sYxp4e0jZtYCfN3dH4miOJG+0riGDJX9Ta38+ZVtlFVWs6FuPwBm9HmcN6FDw91vJxgE72Jm3wa+BVwxEDPCRaLQtTy65mrIIKna187XHniNB9ds42BLOwCTszO5aVEety7OJ2/i6D69bkKHhkiq0qKFMhiaWtt5eO12SiuqWFPTBARXQhWdNJHiwgI+dOY0MjP618IhaULDzK4AfkCP01PuviDCskT6JDvsqaEjDRkIb+9spKyimvtXb2XvoeAPkVEZcEvhCRQX5nPKlJwBe6+kCY1w3EJjF5ISOk9P7dOYhvRRS1sHT6zbQWlFFS9v3tW1ff6scRQXFjBu31t86INnDvj7Jk1oiKSSsVoeXfpo67sHWba8hmUramhobAZg1Ih0rjl7BksXF3DWrHEAlJe/PSjvr9AQiUBX9z6NaUgc2jucZzfWU1ZRzTNv1ndNwjttajYlRQVcc/ZMxoanPAebQkMkAloeXeKxc38z96wMJuFt23MIgMz0ND581jSKCws494QJQ97CQaEhEoGugXCdnpIe3J2XN++irLKax16voy08rMibOIriwgJuXDiLSdkjI6tPoSESgc4jDQ2ES6e9B1u5b/VWyiqr2LzzAABpBpeeMZWSogIuOGVyQrRwUGiIRCCna3KfxjSGM3dnTc0eyiqreejVWprDFg5Tx47klnODpT1mjB8VcZVHUmiIRCAnS33Ch7MDzW08uKaWssoq3qjd17X9glMnU1yYzwdPn8qI9P5NwhssCg2RCGRrIHxYerNuP2WVVTywelvXvp8wegQ3Lspj6eJ8Tpg8JuIKj0+hIRIBLVg4fDS3tfPoa3WUVVaxYsu7XdsXFUyguCifD8+dTtaI9Agr7B2FhkgEuhYsVGikrC0NB7hreTX3rtrK7gMtQLDfrz17JksL8zl9+tiIK+wbhYZIBLJGpJOZnkZLewdNre1J9ZemHF1bewdPrq+nrLKK5zc1dG0/Y/pYiovyuXrBzK4/GJJVclcvksSyszLYfaCFxuY2hUaSq9vbxF3Lq1m2opod+4KlPUZmpHHl/BkUF+azIG/8kE/CGywKDZGIZI8MQmN/UxuTI5ysJX3T0eG88FYDpRVVPLWhnvZwEt5JuWMoLizghnNmMW700CztMZQUGiIRydGihUlp94EW7l1Zw53Lq6nadRAI+mt/ZN50igvzed9Jk1LmqCIWhYZIRLRoYfJwd1ZWvUtZj/7aM8eP4tbFedx0bh5Tco7fXzsVKDREItI1wU9zNRLWvs7+2hXVvLnjcH/ti+dMobgwnyWze9dfOxUoNEQiorkaiev1bXspq6ziwTW13fprj+Tmc2dxy7l976+dChQaIhE5PKah01OJ4FBLOw+traWssppXa/Z0bX/fSZMoLsrnsjP63187FSg0RCJyeExDRxpRequ+kTsrq7lvVU3XqsNjszK4fuEsigsLOGVKdsQVJhaFhkhEOsc0tP7U0Gtp6+DxdXWUVlRRsXl31/b5eeMpKczno/NmMCpTc2diUWiIRKRz0UINhA+dmt0HuWt5NfesrKGhMVjao7O/dnFhAXNnjou4wsSn0BCJyFgNhA+J9g7nmQ3B0h7lG3fiYX/t2VNzKC7KH9L+2qlAoSESkcOLFmogfDDU72/inhU13LW85oj+2lecNY2SogIWFgx9f+1UoNAQiYgaMQ08d+flt3dRWlnF42/s6OqvXTBpNEsX53PjojwmjsmMuMrkptAQiUjXkYbGNPptz8EW7lu1lTsrq9ncEPTXTk8zPnTmVIoLCzg/QfprpwKFhkhENLmvfzr7a5dWVPPw2vf21751cT7Txg2PpT2GkkJDJCKHQ0NjGr1xoLmNP68JlvZYt71nf+0CLjl9ChkJ2l87FSg0RCIyptvpKXfXoOxxbKjbR2lFFX9+pfaI/to3Lcrj1iTpr50KFBoiERmRnsaoEekcam3nYEt7V4jIYU2t7Tz6+nZKK6pZVXW4v/a5J0yguLCAy+dOUwOrIabvUpEIZWdlcKi1nf1NbQqNbrY0HODO5dXcu7KGdw8Gp++yR2Zw3TkzKS4sYPa0nIgrHL70XSoSoZysDHbub6axuRUY3oO2re0dPBWjv/aZM8ZSUlTAVfNnKFgTQMLvATNbAPwdcA5BvSOAJ4HvuvvOKGsT6a+c8JfgvmF8BdX2vYe4a3kNd/for33V/BkUFxUwf9Y4jfckkIQPDWAZ8AZwobsfMLOZwFPA5WY2390PRVueSN91LVo4zEKjo8N5btNOyiqreWr9DsI5eJycO4alKdxfO30h5UgAAArbSURBVBUkQ2gAfNXdDwC4+zYz+ynwG+AK4P5IKxPph+G2PPquxmbuDSfhVe8+3F/7w3OnUVyU+v21U0EyhMY8d2/psa02vJ0w1MWIDKSuRkzNqTtXw91ZseVdSiuq+O/Xj+yvvbQwnxsXzRo2/bVTQcKHRozAADgNcOC5WM8xs9uA2wByc3MpLy8ftPpkYDQ2Ng7L/bSnITiH/8rrbzL1wOaIq4lPvPvqYKvzUm0bz9S0sq0xOP9kwPzcdC7Ky2BerpFmW1m3aivrBrfkYWmwfqYSPjR6MrN04FPAb919Y6zHuPsdwB0As2fP9iVLlgxdgdIn5eXlDMf9tLp1I09UbWLqrAKWLDkt6nLicrx99drWw/21D7Ue7q99y7l53LI4j1kThm9/7aE0WD9TSRcawDeBNuBLURci0l85KbJo4aGWdh56tZbSyirWbt3btf19J02ipKiAy86cyggt7ZESkio0zOyTwE3AEndvjLoekf7KTvL1p96q309pRTX3r97aNZg/NiuDGxbmsbQwX/21U1DShIaZfQz4R+Bid6+Puh6RgXB4IDx5jjTaOpy/vFpLWUUVle8c7q+9IG88xYX5XDl/hpb2SGFJERpmVgJ8FbjE3evCbR8FZoTjFyJJKZkuua3ZfZA7l1dT9tJB9rW8AsDozHSuXjCT4sJ89dceJhI+NMysGPg1wVjGJd2u4b4A2B5VXSIDIdG793X21y6trOLZHv21S8L+2jnqrz2sJHxoAL8gWJTnpzHu+84Q1yIyoBK1p0b9vibuXlHDXcurqd3bBEBmRhofOWs6Z2Tu4tPXXKBJeMNUwoeGu0+MugaRwZJIYxodHc7Lm3dRFqO/dnFhPjcsDPprl5eXKzCGsYQPDZFUlghjGu8eaOH+1bH7a5cUFfD+k9VfWw5TaIhEaExmBmZwsKWd9g4nfYh+Obs7r9TsobSiiofXbqcl7K89fVwWt5ybz83n5qm/tsSk0BCJUFqakZ2Zwf7mNhqb2gZ9ZdfG5jYeXLON0opq1of9tc3gA6flUlyYz8Vz1F9bjk2hIRKxnKwgNPY3tw5aaKzf3tlfexsHWoKlPSaOyeTGRbMoXlxA/iQt7SHxUWiIRCw7KwP2Dvy4RlNrO39du52yyipWV+/p2r74hIkUF+Vz+dxpjMzQJDzpHYWGSMS6GjEN0BVU7zQcoKyiivtWb2VP2F87J+yvvVT9taWfFBoiEeu8gqrzF3xftLZ38OS6HZRWVvHiW7u6ts+dOZaSwgKuVH9tGSD6LhKJ2OxpOTy7cSelFVVcesbUXj23ds8hli2vZtmKGur3B705skYE/bVLigqYN2v8YJQsw5hCQyRin73wJO5aXs2zG3fyzIZ6Lpoz5ZiP7+yvXVpRzdMbjuyvXVJUwHVnq7+2DB6FhkjEJmWP5AsfPJXv/XU93/3rOs4/dXLM3hMNjc3cszJY2qNm9yEARqQbV5w5jZKiAgpPnKiZ2jLoFBoiCeDj7zshmJG98wD/9XIVnzr/RCA4qnjp7V3ctbyax9fV0doeHFbMmhD2116YR27OyChLl2FGoSGSADIz0vjGR07nb/64kn97ciNjR42gcvMunt/UQN2+YMHANINLTp9KcVE+Hzg1V0t7SCQUGiIJ4uI5U7jg1Mk8v6mBL9/7atf2GeOyuFlLe0iCUGiIJAgz49tXncnnSlczZexIzj9lMhecmsucaTk6qpCEodAQSSAn52bz2JcujLoMkaPSymQiIhI3hYaIiMRNoSEiInFTaIiISNwUGiIiEjeFhoiIxE2hISIicVNoiIhI3BQaIiISN4WGiIjETaEhIiJxU2iIiEjcFBoiIhI3hYaIiMRNoSEiInFL+NAwsylmVmZmb4Yf95nZrKjrEhEZjhI6NMwsE3gCyATOBM4ADgDPmFl2lLWJiAxHCR0awP8A5gFfdfc2d28HvgqcBPxtpJWJiAxDiR4a1wPV7r65c4O71wHrwvtERGQIJXpozAPeibH9HeCsIa5FRGTYy4i6gOOYDKyKsX0fMNrMRrn7oZ53mtltwG3hf5vN7PVBrFEGxmSgIeoiJC7aV8mhP/up4Gh3JHpoHI0d6053vwO4A8DMVrr7oiGpSvpM+yl5aF8lh8HaT4l+eqoByImxPQc4GOsoQ0REBk+ih8Za4IQY208EXhvaUkREJNFD4wGgwMxO6NxgZlOB04H743yNOwa+LBkE2k/JQ/sqOQzKfjJ3H4zXHRDh5L6VwHqgGOgAfgucD5zt7o0RliciMuwk9JGGu7cAlwLtBHMz1gNjgYsVGCIiQy+hjzRERCSxJPSRhogkHjN73sy8+1ijDB8pGRpaGTfxmdkCM/u1ma0ys1fNbJ2Z/dzMcqOuTY7OzK4nGFOUBGVm15vZc+HP1mYzW2lmHxuo10+50NDKuEljGTARuNDd5xOMXV0GvGhmoyKtTGIKf7Z+CDwSdS0Sm5l9CfgGsNTdFwKzgY3ABwfqPVIuNNDKuMnkq+5+AMDdtwE/BU4Froi0KjmavyO4mnFF1IXIe4WnC38EfNbdtwK4eyvwZeA/Bup9UjE0tDJucpjn7m/12FYb3k4Y6mLk2MxsIvAV4OtR1yJH9TFgj7sfEeruXuvuKwfqTVIxNLQybhIIL6fu6TTAgeeGuBw5vtuBUnffEnUhclTnAVvCMY3nzWyDmb1kZp8ayDdJ1gULj6VPK+NKtMwsHfgU8Ft33xh1PXKYmZ0C3ESwEoMkrjyCZZe+DFwL1BOcXbnLzKa7+/cH4k1S8UjjaI65Mq5E7ptAG/ClqAuR9/gJ8CN33xt1IXJMWcAY4CvuXufuHe5+L/Ag8HUzGz0Qb5KKoaGVcZOMmX2S4C/ZD2umf2IxswuAucD/iboWOa794e2aHttfAUYTXEnab6l4emotMCfGdq2Mm4DC68f/kWBpmPqo65H3uBRIB1aYdR2sTwtvHzGzFuDr7q7LcKO3AVjAew8G2sPbATlISMUjjYFYGVeGgJmVEFwOfUl4hRtm9tGw86IkAHe/3d1PdvcFnR/Ar8K7rwi3KTASw0Ph7bwe2+cCh4A3BuJNUjE0/kBwRPFjM8swszSCa5ffQYfYCcPMioFfE+yvS8ysJAyRK4EZUdYmkqTuJphD873Oiczh6cUbgO93zonqr5RcsDA8svhXYBHBJZyvA19095pIC5MuZrabo8/H+I67f3sIy5E4mNkVwA8ITk9NJVh1uiU8+pAEEM6n+THB6gpNQDPwC3f/9YC9RyqGhoiIDI5UPD0lIiKDRKEhIiJxU2iIiEjcFBoiIhI3hYaIiMRNoSEiInFTaIiISNwUGiIiEjeFhoiIxE2hISIicVNoiIhI3BQaIkPEzMrMbJ+ZdZjZk+G2X5rZu2b2jpl9OuoaRY5HCxaKDCEzuxG4B/iMu//GzAoI+iCcp66FkgwUGiJDzMweAC4h6LL2O+AH7v54tFWJxEehITLEzGwasI6gDefD7v7JiEsSiZvGNESGWNja9jvAZOCZiMsR6RUdaYgMsbAFcTkwCsgHznT3hkiLEomTjjREht4XgErgGiAL+PdoyxGJn440RIaQmZ0M3EdwtdQhM/ss8CvgSnd/ONrqRI5PRxoiQ8TMvg+8AEwDPhVu/lx4W2Zm90VSmEgv6EhDRETipiMNERGJm0JDRETiptAQEZG4KTRERCRuCg0REYmbQkNEROKm0BARkbgpNEREJG4KDRERidv/ByERQVS08GEzAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the initial conditions.\n", + "pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.title('Initial conditions')\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('u')\n", + "pyplot.grid()\n", + "pyplot.plot(x, u0, color='C0', linestyle='-', linewidth=2)\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 10.0);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is definitely not the hat function we've been dealing with until now. We call it a \"saw-tooth function\". Let's proceed forward and see what happens. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Periodic Boundary Conditions\n", + "\n", + "We will implement Burgers' equation with *periodic* boundary conditions. If you experiment with the linear and non-linear convection notebooks and make the simulation run longer (by increasing `nt`) you will notice that the wave will keep moving to the right until it no longer even shows up in the plot. \n", + "\n", + "With periodic boundary conditions, when a point gets to the right-hand side of the frame, it *wraps around* back to the front of the frame. \n", + "\n", + "Recall the discretization that we worked out at the beginning of this notebook:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u_i^{n+1} = u_i^n - u_i^n \\frac{\\Delta t}{\\Delta x} (u_i^n - u_{i-1}^n) + \\nu \\frac{\\Delta t}{\\Delta x^2}(u_{i+1}^n - 2u_i^n + u_{i-1}^n)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "What does $u_{i+1}^n$ *mean* when $i$ is already at the end of the frame?\n", + "\n", + "Think about this for a minute before proceeding." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Integrate the Burgers' equation in time.\n", + "u = u0.copy()\n", + "for n in range(nt):\n", + " un = u.copy()\n", + " # Update all interior points.\n", + " u[1:-1] = (un[1:-1] -\n", + " un[1:-1] * dt / dx * (un[1:-1] - un[:-2]) +\n", + " nu * dt / dx**2 * (un[2:] - 2 * un[1:-1] + un[:-2]))\n", + " # Update boundary points.\n", + " u[0] = (un[0] -\n", + " un[0] * dt / dx * (un[0] - un[-1]) +\n", + " nu * dt / dx**2 * (un[1] - 2 * un[0] + un[-1]))\n", + " u[-1] = (un[-1] -\n", + " un[-1] * dt / dx * (un[-1] - un[-2]) +\n", + " nu * dt / dx**2 * (un[0] - 2 * un[-1] + un[-2]))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute the analytical solution.\n", + "u_analytical = numpy.array([u_lamb(nt * dt, xi, nu) for xi in x])" + ] + }, + { + "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": [ + "# Plot the numerical solution along with the analytical solution.\n", + "pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('u')\n", + "pyplot.grid()\n", + "pyplot.plot(x, u, label='Numerical',\n", + " color='C0', linestyle='-', linewidth=2)\n", + "pyplot.plot(x, u_analytical, label='Analytical',\n", + " color='C1', linestyle='--', linewidth=2)\n", + "pyplot.legend()\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 10.0);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's now create an animation with the `animation` module of Matplotlib to observe how the numerical solution changes over time compared to the analytical solution.\n", + "We start by importing the module from Matplotlib as well as the special `HTML` display method." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import animation\n", + "from IPython.display import HTML" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We create a function `burgers` to computes the numerical solution of the 1D Burgers' equation over time.\n", + "(The function returns the history of the solution: a list with `nt` elements, each one being the solution in the domain at a time step.)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def burgers(u0, dx, dt, nu, nt=20):\n", + " \"\"\"\n", + " Computes the numerical solution of the 1D Burgers' equation\n", + " over the time steps.\n", + " \n", + " Parameters\n", + " ----------\n", + " u0 : numpy.ndarray\n", + " The initial conditions as a 1D array of floats.\n", + " dx : float\n", + " The grid spacing.\n", + " dt : float\n", + " The time-step size.\n", + " nu : float\n", + " The viscosity.\n", + " nt : integer, optional\n", + " The number of time steps to compute;\n", + " default: 20.\n", + " \n", + " Returns\n", + " -------\n", + " u_hist : list of numpy.ndarray objects\n", + " The history of the numerical solution.\n", + " \"\"\"\n", + " u_hist = [u0.copy()]\n", + " u = u0.copy()\n", + " for n in range(nt):\n", + " un = u.copy()\n", + " # Update all interior points.\n", + " u[1:-1] = (un[1:-1] -\n", + " un[1:-1] * dt / dx * (un[1:-1] - un[:-2]) +\n", + " nu * dt / dx**2 * (un[2:] - 2 * un[1:-1] + un[:-2]))\n", + " # Update boundary points.\n", + " u[0] = (un[0] -\n", + " un[0] * dt / dx * (un[0] - un[-1]) +\n", + " nu * dt / dx**2 * (un[1] - 2 * un[0] + un[-1]))\n", + " u[-1] = (un[-1] -\n", + " un[-1] * dt / dx * (un[-1] - un[-2]) +\n", + " nu * dt / dx**2 * (un[0] - 2 * un[-1] + un[-2]))\n", + " u_hist.append(u.copy())\n", + " return u_hist" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute the history of the numerical solution.\n", + "u_hist = burgers(u0, dx, dt, nu, nt=nt)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute the history of the analytical solution.\n", + "u_analytical = [numpy.array([u_lamb(n * dt, xi, nu) for xi in x])\n", + " for n in range(nt)]" + ] + }, + { + "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": [ + "fig = pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel('x')\n", + "pyplot.ylabel('u')\n", + "pyplot.grid()\n", + "u0_analytical = numpy.array([u_lamb(0.0, xi, nu) for xi in x])\n", + "line1 = pyplot.plot(x, u0, label='Numerical',\n", + " color='C0', linestyle='-', linewidth=2)[0]\n", + "line2 = pyplot.plot(x, u0_analytical, label='Analytical',\n", + " color='C1', linestyle='--', linewidth=2)[0]\n", + "pyplot.legend()\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 10.0)\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "def update_plot(n, u_hist, u_analytical):\n", + " \"\"\"\n", + " Update the lines y-data of the Matplotlib figure.\n", + " \n", + " Parameters\n", + " ----------\n", + " n : integer\n", + " The time-step index.\n", + " u_hist : list of numpy.ndarray objects\n", + " The history of the numerical solution.\n", + " u_analytical : list of numpy.ndarray objects\n", + " The history of the analytical solution.\n", + " \"\"\"\n", + " fig.suptitle('Time step {:0>2}'.format(n))\n", + " line1.set_ydata(u_hist[n])\n", + " line2.set_ydata(u_analytical[n])" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# Create an animation.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(u_hist, u_analytical),\n", + " interval=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Array Operation Speed Increase" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Coding up discretization schemes using array operations can be a bit of a pain. It requires much more mental effort on the front-end than using two nested `for` loops. So why do we do it? Because it's fast. Very, very fast.\n", + "\n", + "Here's what the Burgers code looks like using two nested `for` loops. It's easier to write out, plus we only have to add one \"special\" condition to implement the periodic boundaries. \n", + "\n", + "At the top of the cell, you'll see the decorator `%%timeit`.\n", + "This is called a \"cell magic\". It runs the cell several times and returns the average execution time for the contained code. \n", + "\n", + "Let's see how long the nested `for` loops take to finish." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23.1 ms ± 344 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "# Set initial conditions.\n", + "u = numpy.array([u_lamb(t, x0, nu) for x0 in x])\n", + "# Integrate in time using a nested for loop.\n", + "for n in range(nt):\n", + " un = u.copy()\n", + " # Update all interior points and the left boundary point.\n", + " for i in range(nx - 1):\n", + " u[i] = (un[i] -\n", + " un[i] * dt / dx *(un[i] - un[i - 1]) +\n", + " nu * dt / dx**2 * (un[i + 1] - 2 * un[i] + un[i - 1]))\n", + " # Update the right boundary.\n", + " u[-1] = (un[-1] -\n", + " un[-1] * dt / dx * (un[-1] - un[-2]) +\n", + " nu * dt / dx**2 * (un[0]- 2 * un[-1] + un[-2]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Less than 50 milliseconds. Not bad, really. \n", + "\n", + "Now let's look at the array operations code cell. Notice that we haven't changed anything, except we've added the `%%timeit` magic and we're also resetting the array `u` to its initial conditions. \n", + "\n", + "This takes longer to code and we have to add two special conditions to take care of the periodic boundaries. Was it worth it?" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.52 ms ± 64.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "# Set initial conditions.\n", + "u = numpy.array([u_lamb(t, xi, nu) for xi in x])\n", + "# Integrate in time using array operations.\n", + "for n in range(nt):\n", + " un = u.copy()\n", + " # Update all interior points.\n", + " u[1:-1] = (un[1:-1] -\n", + " un[1:-1] * dt / dx * (un[1:-1] - un[:-2]) +\n", + " nu * dt / dx**2 * (un[2:] - 2 * un[1:-1] + un[:-2]))\n", + " # Update boundary points.\n", + " u[0] = (un[0] -\n", + " un[0] * dt / dx * (un[0] - un[-1]) +\n", + " nu * dt / dx**2 * (un[1] - 2 * un[0] + un[-1]))\n", + " u[-1] = (un[-1] -\n", + " un[-1] * dt / dx * (un[-1] - un[-2]) +\n", + " nu * dt / dx**2 * (un[0] - 2 * un[-1] + un[-2]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Yes, it is absolutely worth it. That's a nine-fold speed increase. For this exercise, you probably won't miss the extra 40 milliseconds if you use the nested `for` loops, but what about a simulation that has to run through millions and millions of iterations? Then that little extra effort at the beginning will definitely pay off. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MAE6286)", + "language": "python", + "name": "py36-mae6286" + }, + "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.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/02_spacetime/README.md b/2-finite-difference-method/lessons/02_spacetime/README.md new file mode 100644 index 0000000..c1c644b --- /dev/null +++ b/2-finite-difference-method/lessons/02_spacetime/README.md @@ -0,0 +1,41 @@ +# Module 2: +## Space & Time: Introduction to numerical solution of PDEs + +## Summary +This module lays the foundation for numerical solution of partial differential equations (PDEs), where the unknown is a multi-variate function. + +* [Lesson 1](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_01_1DConvection.ipynb) starts with the simplest model: the one-dimensional linear convection equation, and explains the finite-difference method of discretizing derivatives. It demonstrates the first-order forward-time, backward-space method and discusses truncation error. It then shows how to solve the nonlinear convection equation, and explains vectorized stencil operations. +* [Lesson 2](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_02_CFLCondition.ipynb) treats stability and the CFL condition, including numerical experimentation and a graphical interpretation using the idea of domain of dependence of the numerical scheme. +* [Lesson 3](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_03_1DDiffusion.ipynb) deals with the one-dimensional diffusion equation, and introduces the discretization of second-order derivatives. It also shows how to create animations within IPython Notebooks. +* [Lesson 4](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_04_1DBurgers.ipynb) combines previous results to demonstrate a solution of the Burgers' equation. It introduces SymPy for symbolic computations and uses periodic boundary conditions for the first time. It also demonstrates computational speed differences when using array operations. + + +## Badge earning +Completion of this module in the online course platform can earn the learner the Module 2 badge. + +### Description: What does this badge represent? + +The earner of this badge has completed Module 2 of the course "Practical Numerical Methods with Python." This module lays the foundation for the numerical solution of PDEs, including: one-dimensional linear convection, non-linear convection, diffusion and Burgers' equation. + +### Criteria: What needs to be done to earn it? +To earn this badge, the learner needs to complete the graded assessment in the course platform including: answering quiz about stencils of numerical schemes; answering quiz questions about stability and using sympy; completing the individual coding assignment "Traffic flow" and answering the numeric questions online. +Earners should also have completed self-study of the four module lessons, by reading, reflecting on and writing their own version of the codes. This is not directly assessed, but it is assumed. Thus, earners are encouraged to provide evidence of this self-study by giving links to their code repositories or other learning objects they created in the process. + +### Evidence: Website (link to original digital content) +Desirable: link to the earner's GitHub repository (or equivalent) containing the solution to the "Traffic flow" coding assignment. + +Optional: link to the earner's GitHub repository (or equivalent) containing other codes, following the lesson. + +### Category: +Higher education, graduate + +### Tags: +engineering, computation, higher education, numericalmooc, python, gwu, george washington university, lorena barba, github + +### Relevant Links: Is there more information on the web? + +[Course About page](http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/about) + +[Course wiki](http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/wiki/GW.MAE6286.2014_fall/) + +[Course GitHub repo](https://github.com/numerical-mooc/numerical-mooc) diff --git a/2-finite-difference-method/lessons/02_spacetime/figures/CFLcondition.png b/2-finite-difference-method/lessons/02_spacetime/figures/CFLcondition.png new file mode 100644 index 0000000..ba42b6d Binary files /dev/null and b/2-finite-difference-method/lessons/02_spacetime/figures/CFLcondition.png differ diff --git a/2-finite-difference-method/lessons/02_spacetime/figures/FDapproxiamtions.png b/2-finite-difference-method/lessons/02_spacetime/figures/FDapproxiamtions.png new file mode 100644 index 0000000..e402382 Binary files /dev/null and b/2-finite-difference-method/lessons/02_spacetime/figures/FDapproxiamtions.png differ diff --git a/2-finite-difference-method/lessons/02_spacetime/figures/FTBS_stencil.png b/2-finite-difference-method/lessons/02_spacetime/figures/FTBS_stencil.png new file mode 100644 index 0000000..3ebfe16 Binary files /dev/null and b/2-finite-difference-method/lessons/02_spacetime/figures/FTBS_stencil.png differ diff --git a/2-finite-difference-method/lessons/02_spacetime/figures/characteristics.png b/2-finite-difference-method/lessons/02_spacetime/figures/characteristics.png new file mode 100644 index 0000000..22d2f9a Binary files /dev/null and b/2-finite-difference-method/lessons/02_spacetime/figures/characteristics.png differ diff --git a/2-finite-difference-method/lessons/02_spacetime/figures/squarewave.png b/2-finite-difference-method/lessons/02_spacetime/figures/squarewave.png new file mode 100644 index 0000000..a9c8ed2 Binary files /dev/null and b/2-finite-difference-method/lessons/02_spacetime/figures/squarewave.png differ diff --git a/2-finite-difference-method/lessons/02_spacetime/figures/stencil-1.png b/2-finite-difference-method/lessons/02_spacetime/figures/stencil-1.png new file mode 100644 index 0000000..7a3112e Binary files /dev/null and b/2-finite-difference-method/lessons/02_spacetime/figures/stencil-1.png differ diff --git a/2-finite-difference-method/lessons/02_spacetime/figures/stencil-2.png b/2-finite-difference-method/lessons/02_spacetime/figures/stencil-2.png new file mode 100644 index 0000000..0ebcec6 Binary files /dev/null and b/2-finite-difference-method/lessons/02_spacetime/figures/stencil-2.png differ diff --git a/2-finite-difference-method/lessons/02_spacetime/figures/stencil-3.png b/2-finite-difference-method/lessons/02_spacetime/figures/stencil-3.png new file mode 100644 index 0000000..824f5e8 Binary files /dev/null and b/2-finite-difference-method/lessons/02_spacetime/figures/stencil-3.png differ diff --git a/2-finite-difference-method/lessons/02_spacetime/figures/stencil-4.png b/2-finite-difference-method/lessons/02_spacetime/figures/stencil-4.png new file mode 100644 index 0000000..a92aa76 Binary files /dev/null and b/2-finite-difference-method/lessons/02_spacetime/figures/stencil-4.png differ diff --git a/2-finite-difference-method/lessons/02_spacetime/figures/vectorizedstencil.png b/2-finite-difference-method/lessons/02_spacetime/figures/vectorizedstencil.png new file mode 100644 index 0000000..08703a5 Binary files /dev/null and b/2-finite-difference-method/lessons/02_spacetime/figures/vectorizedstencil.png differ diff --git a/2-finite-difference-method/lessons/02_spacetime/figures/vectorizedstencil.svg b/2-finite-difference-method/lessons/02_spacetime/figures/vectorizedstencil.svg new file mode 100644 index 0000000..dcc2096 --- /dev/null +++ b/2-finite-difference-method/lessons/02_spacetime/figures/vectorizedstencil.svg @@ -0,0 +1,994 @@ + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/03_wave/03_01_conservationLaw.ipynb b/2-finite-difference-method/lessons/03_wave/03_01_conservationLaw.ipynb new file mode 100644 index 0000000..841303e --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/03_01_conservationLaw.ipynb @@ -0,0 +1,2571 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, C.D. Cooper, G.F. Forsyth." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Riding the wave" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Convection problems" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome to *Riding the wave: Convection problems*, the third module of [\"Practical Numerical Methods with Python\"](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about). \n", + "\n", + "In the [first module](https://github.com/numerical-mooc/numerical-mooc/tree/master/lessons/01_phugoid), we learned about numerical integration methods for the solution of ordinary differential equations (ODEs). The [second module](https://github.com/numerical-mooc/numerical-mooc/tree/master/lessons/02_spacetime) introduced the finite difference method for numerical solution of partial differential equations (PDEs), where we need to discretize both *space* and *time*.\n", + "\n", + "This module explores the convection equation in more depth, applied to a traffic-flow problem. We already introduced convection in [Lesson 1 of Module 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_01_1DConvection.ipynb). This hyperbolic equation is very interesting because the solution can develop *shocks*, or regions with very high gradient, which are difficult to resolve well with numerical methods. \n", + "\n", + "We will start by introducing the concept of a conservation law, closely related to the convection equation. Then we'll explore different numerical schemes and how they perform when shocks are present." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conservation laws" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You know from (non relativistic) physics that mass is _conserved_. This is one example of a conserved quantity, but there are others (like momentum and energy) and they all obey a _conservation law_. Let's start with the more intuitive case of conservation of mass." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Conservation of mass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In any closed system, we know that the mass $M$ in the system does not change, which we can write: $\\frac{D\\,M}{Dt} =0$. When we change the point of view from a closed system to what engineers call a _control volume_, mass can move in and out of the volume and conservation of mass is now expressed by:\n", + "\n", + "![massconservation-CV](./figures/massconservation-CV.png)\n", + "\n", + "Let's imagine the control volume as a tiny cylinder of cross-section dA and length dx, like in the sketch below.\n", + "\n", + "![1Dcontrolvolume](./figures/1Dcontrolvolume.png)\n", + "#### Figure 1. Tiny control volume in the shape of a cylinder.\n", + "\n", + "If we represent the mass density by $\\rho$, then mass is equal to $\\rho\\times$ volume. For simplicity, let's assume that mass flows in or out of the control volume only in one direction, say, the $x$-direction. Express the 1D velocity component by $u$, and conservation of mass for the control volume is translated to a mathematical expression as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial}{\\partial t}\\int_{\\text{cv}}\\rho \\, dV + \\int_{\\text{cs}}\\rho \\, u\\, dA =0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where \"cv\" stands for control volume and \"cs\" stands for control surface. The first term represents the rate of change of mass in the control volume, and the second term is the rate of flow of mass, with velocity $u$, across the control surface." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the control volume is very small, we can take, to leading order, $\\rho$ as a uniform quantity inside it, and the first term in equation (1) can be simplified to the time derivative of density multiplied by the volume of the tiny cylinder, $dAdx$:\n", + "\n", + "$$\n", + "\\frac{\\partial}{\\partial t}\\int_{\\text{cv}}\\rho \\, dV \\rightarrow \\frac{\\partial \\rho}{\\partial t} dA dx\n", + "$$\n", + "\n", + "Now, for the second term in equation (1), we have to do a little more work. The quantity inside the integral is now $\\rho u$ and, to leading order, we have to take into consideration that this quantity can change in the distance $dx$. Take $\\rho u$ to be the value in the center of the cylinder. Then the flow of mass on each side is illustrated in the figure below, where we use a Taylor expansion of the quantity $\\rho u$ around the center of the control volume (to first order)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![1Dfluxbalance](./figures/1Dfluxbalance.png)\n", + "#### Figure 2. Flux terms on the control surfaces." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Subtracting the negative flux on the left to the positive flux on the right, we arrive at the total flux of mass across the control surfaces, the second term in equation (1):\n", + "\n", + "$$\n", + "\\int_{\\text{cs}}\\rho \\, u\\, dA \\rightarrow \\frac{\\partial}{\\partial x}(\\rho u) dA dx\n", + "$$\n", + "\n", + "We can now put together the equation of conservation of mass for the tiny cylindrical control volume, which after diving by $dA dx$ is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial \\rho}{\\partial t} + \\frac{\\partial}{\\partial x}(\\rho u)=0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This is the 1D mass conservation equation in differential form. If we take $u$ to be a constant and take it out of the spatial derivative this equation looks the same as the first PDE we studied: the linear convection equation in [Lesson 1 of Module 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_01_1DConvection.ipynb).\n", + "But in the form shown above, it is a typical _conservation law_. The term under the spatial derivative is called the _flux_, for reasons that should be clear from our discussion above: it represents amounts of the conserved quantity flowing across the boundary of the control volume." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Dig deeper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can follow the derivation of the full three-dimensional equation of conservation of mass for a flow on this screencast by Prof. Barba (duration 12:47)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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\n", + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import YouTubeVideo\n", + "YouTubeVideo('35unQgSaT88')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### General conservation laws" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All conservation laws express the same idea: the variation of a conserved quantity inside a control volume is due to the total flux of that quantity crossing the boundary surface (plus possibly the effect of any sources inside the volume, but let's ignore those for now).\n", + "\n", + "The _flux_ is a fundamental concept in conservation laws: it represents the amount of the quantity that crosses a surface per unit time. Our discussion above was limited to flow in one dimension, but in general the flux has any direction and is a vector quantity. Think about this: if the direction of flow is parallel to the surface, then no quantity comes in or out. We really only care about the component of flux perpendicular to the surface. Mathematically, for a vector flux $\\vec{F}$, the amount of the conserved quantity crossing a small surface element is:\n", + "\n", + "$$\n", + "\\vec{F}\\cdot d\\vec{A}\n", + "$$\n", + "\n", + "where $d\\vec{A}$ points in the direction of the outward normal to the surface. A general conservation law for a quantity $e$ is thus (still ignoring possible sources):\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial}{\\partial t}\\int_{\\text{cv}}e \\, dV + \\oint_{\\text{cs}}\\vec{F}\\cdot d\\vec{A} =0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "To obtain a differential form of this conservation equation, we can apply the theorem of Gauss to the second integral, which brings the gradient of $\\vec{F}$ into play. One way to recognize a conservation law in differential form is that the _fluxes appear only under the gradient operator_.\n", + "\n", + "Recall the non-linear convection equation from [Lesson 1 of Module 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_01_1DConvection.ipynb). It was:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial u}{\\partial t} + u \\frac{\\partial u}{\\partial x} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "If we look closely at the spatial derivative, we can rewrite this equation as\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial u}{\\partial t} + \\frac{\\partial}{\\partial x} \\left(\\frac{u^2}{2} \\right) = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "which is the *conservation form* of the non-linear convection equation, with flux $F=\\frac{u^2}{2}$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Traffic flow model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We've all experienced it: as rush hour approaches certain roads in or out of city centers start getting full of cars, and the speed of travel can reduce to a crawl. Sometimes, the cars stop altogether. If you're a driver, you know that the more cars on the road, the slower your trip will flow.\n", + "\n", + "Traffic flow models seek to describe these everyday experiences with mathematics, to help engineers design better road systems.\n", + "\n", + "Let's review the [Lighthill-Whitham-Richards](http://en.wikipedia.org/wiki/Macroscopic_traffic_flow_model) traffic model that was offered as an exercise at the end of Module 2. This model considers cars with a continuous *traffic density* (average number of cars per unit length of road) rather than keeping track of them individually. If $\\rho(x)=0$, there are no cars at that point $x$ of the road. If $\\rho(x) = \\rho_{\\rm max}$, traffic is literally bumper to bumper.\n", + "\n", + "If the number of cars on a bounded stretch of road changes, it means that cars are entering or leaving the road somehow. _Traffic density obeys a conservation law_ (!) where the flux is the number of cars leaving the road per unit time. It is given by $F=\\rho u$—as with mass conservation, flux equals density times velocity. But don't forget your experience on the road: the speed of travel depends on the car density. Here, $u$ refers not to the speed of each individual car, but to the _traffic speed_ at a given point of the road. \n", + "\n", + "You know from experience that with more cars on the road, the speed of travel decreases. It is also true that if you are traveling at fast speed, you are advised to leave a larger gap with cars ahead. These two considerations lead us to propose a monotonically decreasing $u=u(\\rho)$ function. As a first approximation, we may consider the linear function:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u(\\rho) = u_{\\rm max} \\left(1-\\frac{\\rho}{\\rho_{\\rm max}}\\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "![velocityvsdensity](./figures/velocityvsdensity.png)\n", + "#### Figure 3. Traffic speed vs. traffic density.\n", + "\n", + "The linear model of the behavior of drivers satisfies these experimental observations: \n", + "1. All drivers will approach a maximum velocity $u_{max}$ when the road is empty.\n", + "2. If the road is completely jampacked ($\\rho \\rightarrow \\rho_{max}$), velocity goes to zero. \n", + "\n", + "That seems like a reasonable approximation of reality! \n", + "\n", + "Applying a conservation law to the vehicle traffic, the traffic density will obey the following transport equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial \\rho}{\\partial t} + \\frac{\\partial F}{\\partial x} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $F$ is the *traffic flux*, which in the linear traffic-speed model is given by: \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "F = \\rho u_{\\rm max} \\left(1-\\frac{\\rho}{\\rho_{\\rm max}}\\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We can now use our numerical kung-fu to solve some interesting traffic situations, and check if our simple model gives realistic results!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Green light!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's say that we are examining a road of length $4$ where the speed limit is $u_{\\rm max}=1$, fitting $10$ cars per unit length $(\\rho_{\\rm max}=10)$. Now, imagine we have an intersection with a red light at $x=2$. At the stoplight, traffic is bumper-to-bumper, and the traffic density decreases linearly to zero as we approach the beginning of our road. Ahead of the stoplight, the road is clear.\n", + "\n", + "Mathematically, we can represent this situation with the following initial condition:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\rho(x,0) = \\left\\{\n", + "\\begin{array}{cc}\n", + "\\rho_{\\rm max}\\frac{x}{2} & 0 \\leq x < 2 \\\\\n", + "0 & 2 \\leq x \\leq 4 \\\\\n", + "\\end{array}\n", + "\\right.\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Let's see what a plot of that looks like." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def rho_green_light(x, rho_light):\n", + " \"\"\"\n", + " Computes the \"green light\" initial condition.\n", + " It consists of a shock with a linear distribution behind it.\n", + " \n", + " Parameters\n", + " ----------\n", + " x : numpy.ndaray\n", + " Locations on the road as a 1D array of floats.\n", + " rho_light : float\n", + " Car density at the stoplight.\n", + " \n", + " Returns\n", + " -------\n", + " rho : numpy.ndarray\n", + " The initial car density along the road as a 1D array of floats.\n", + " \"\"\"\n", + " rho = numpy.zeros_like(x)\n", + " mask = numpy.where(x < 2.0)\n", + " rho[mask] = rho_light * x[mask] / 2.0\n", + " return rho" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "nx = 81 # number of locations on the road\n", + "L = 4.0 # length of the road\n", + "dx = L / (nx - 1) # distance between two consecutive locations\n", + "nt = 30 # number of time step to compute\n", + "u_max = 1.0 # maximum speed allowed on the road\n", + "rho_max = 10.0 # maximum car density allowed on the road\n", + "rho_light = 10.0 # car density at the stoplight\n", + "\n", + "# Discretize the road.\n", + "x = numpy.linspace(0.0, L, num=nx)\n", + "\n", + "# Compute the initial traffic density.\n", + "rho0 = rho_green_light(x, rho_light)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEYCAYAAAB2qXBEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl4VdW9xvHvLzNhFAgggoIiCMggEGxVbLRqrVWr4lCnMqj0Wqu9tlqtdazaOvV6a1utVCE413m4zrXGuZIAMskgMs+TQBLIcHLW/eOcBESQhHOSvc/K+3mePHncyUneZxvyZq+91trmnENERGRvpQUdQEREUpuKREREEqIiERGRhKhIREQkISoSERFJiIpEREQSoiIREZGEqEhERCQhKhIREUlIRtABGlu7du1cr169go7hhfLyclq2bBl0DG/ofCaXzmfyTJkyZb1zLq++n+99kXTu3JmSkpKgY3ihqKiIgoKCoGN4Q+czuXQ+k8fMljTk8zW0JSIiCVGRiIhIQlQkIiKSEBWJiIgkREUiIiIJUZGIiEhCVCQiIpIQFYmIiCRERSIiIglRkYiISEJUJCIikpBAi8TM9jWzN8zMBZlDRET2XmBFYmanA58AB+3h8zLN7FYzm2tms8zsYzM7qmlSiojIngR5RXItcDzw0R4+7y/AOcAI59yhwATgbTMb3Mj5RESkHoIskiOdc1982yeYWR9gHHCHc24dgHPuIWAhcHvjRxQRkT0JrEicc5F6fNrpgAHv7nT838AJZtYq6cFERKRBwj5rayAQBZbudHwRsYdy9WvyRCIi8jVhf0JiR2Crc65mp+Nb4u877OpFZjaO2JAYeXl5FBUVNVrA5qSsrEznMol0PpNL5zM4YS+S3bFv+6BzbjwwHqBPnz5Oj99MDj3KNLl0PpNL5zM4YR/aWg/kmln6Tsdbx99vaOI8IiKyk7AXyQxiGbvvdLwnEAHmNHkikb3gnNbcir/CXiQvAA4o2On4McBbzrnSJk8k0kDzVpdScE8Rf3prXtBRRBpFqIvEOTeP2L2O35pZRwAzG0tsNfzvgswmUh+rNm9j1ITJLNmwlXfnrQ06jkijCOxmu5ndTWxl+/7x//4s/qHhzrmqHT71cuAm4CMzqwZKgROcc58hEmKbt1UzekIxq7dUABCp0fCW+CmwInHOXV3Pz6sGro+/iaSEykgNP3u0hHlrSmnfMouN5VVU1USDjiXSKEI9tCWSiqJRx9XPzOA/CzeS1zqbv553GADVKhLxVKquIxEJrTvfmMvL01fSMiudwjH5tG+ZBUB1RENb4iddkYgkUeFHi3jw/YVkpBkPXDCU/l3bkpEW+2emKxLxlYpEJEnemLWKW/7vcwDuGDmQo3vnAZCVHvtnpnsk4isViUgSlCzeyC+f+gzn4KoTenPm0G51H8vMiO3oo1lb4isViUiCFqwt4+JHSqiMRDnv8P257JheX/t4ZrqGtsRvKhKRBKwtrWD0xMls2lrNcX078ftT+2P29T1FM9LiVyRRRzSqqxLxj4pEZC+VVUYYM7GY5V9tY1D3dtx37mFkpH/zn5SZ1d0nqY7qqkT8oyIR2QvVNVF+/vhUZq/cwgEdcnl41DBys3Y/mz4j3eKv0xWJ+EdFItJAzjl++/xM3p+/jg4ts5g0ZjgdW2V/62tq75NEdJ9EPKQiEWmge9+ez7NTlpOTmcbDo/Pp0bHlHl+TqSnA4jEViUgDPPHpUu779wLSDP567hAGd29Xr9dlaWhLPKYiEamnd+as4foXZwJw22kDOK5f53q/NjMjfrM9oisS8Y+KRKQepi/bxC+emEbUweXH9uK8w/dv0OtrpwBrLYn4SEUisgeL15cztrCYbdU1jBzSjV8d37vBX2P7okQNbYl/VCQi32JDWSWjJ05mQ3kVIw7uyB0jB3xjwWF9ZGVodbv4S0Uishvbqmq4aFIJizdspX/XNjxwwdC6K4uG0jYp4jMVicguRGqiXP7kVD5bton92rVg4uh8WmXv/eN7MuOztjT9V3ykIhHZiXOOm16ezb/mrKVti0wmjc2nU5uchL6m7pGIz1QkIju5v+hLHv90KVkZaTw8ahi9OrVO+GvWFYmm/4qHVCQiO3h+6nLufnMeZvDncwYzrEf7pHzd2qGtiDZtFA+pSETiPvhiHb95dgYAN57cjx8O2DdpX3v7Fika2hL/qEhEgNkrN3PpY1OJRB3jjj6QMUf2TOrXz9LQlnhMRSLN3vKvtjJmYjFllRFOGdSVa088JOnfQ9N/xWcqEmnWNm+tZvTEYtaWVnJ4z/bcc9ZA0tIavuBwT7Y/j0RFIv4JfZGY2TAze93M5pjZTDObbGZnBZ1LUl9FdQ2XPFLCgrVl9O7civE/HUZ2RnqjfC9N/xWfhbpIzKwH8A6wHhjgnBsATACeNrNTAowmKS4adfz66elMXryRLm1yKBwznLYtMhvt+2mLFPFZqIsEOAloA/yPcy4C4Jz7O7AFOC/IYJLabn9tDq/OXEXr7AwKx+bTtV2LRv1+mRraEo+FvUgi8fd1e1NYbMe8NKBxxiDEew99sJCHP1xEZrrx4IVDOaRLm0b/npr+Kz4Le5E8BcwFrjezVmaWBlwHZAN/DzSZpKRXZ6zitlfnAHDPWYM4olfHJvm+mrUlPtv7XeiagHNui5l9H5hI7D5JGbAZON45997uXmdm44BxAHl5eRQVFTVBWv+VlZWl9Lmct7GGu4srADi7dyZtN31BUdEXTfK9ly6uBmDR4iUUFa0GUv98ho3OZ3BCXSRm1ofYzfbXgPZABXA28LyZXeCce31Xr3POjQfGA/Tp08cVFBQ0TWDPFRUVkarncv6aUq544GMiDkZ99wBuPrX/Xj1XZG8tylwE8z6nS9duFBT0B1L7fIaRzmdwwj60dSvQDvilc26rcy7qnHsKeB+YZGahLkIJhzVbKhg9YTJbKiL8oH9nbjylaUsEdrxHoqEt8U/Yi2QAsNw5t22n4/OBPCC5+1iId0orqhk1YTIrN1cw9IB9+PNPDiO9ERYc7om2SBGfhb1I1gL77uLK4wDAAV81fSRJFVWRKJc+NpW5q0s5sGNLHvrpMHIyg5nsl5mh6b/ir7AXyV+IrSP5fXzaL2Z2DHAG8E/n3Pogw0l4Oee45rkZfLhgPR1bZTNp7HD2aZkVWJ6MNK1sF3+F+h6Dc+5ZMzsRuBb43MxqgCjwO+C+QMNJqN395jxemLaC3Kx0Jo7Op3v73EDzaPqv+CzURQLgnHsTeDPoHJI6Hv3PEu4v+pL0NOP+84cwoFvboCORpaEt8VjYh7ZEGuSt2au56aVZAPzxjAEU9OkUcKIYbdooPlORiDemLPmKy5+cRtTBlcf15uxh3YOOVEfTf8VnKhLxwsJ1ZVw8qZjKSJRzhnXniu/3CjrS12jTRvGZikRS3rrSSkZNnMxXW6s5pk8et59+aJMvONyT2iuSiIa2xEMqEklp5ZURxhYWs2zjNgZ2a8tfzxtCRnr4fqw1a0t8Fr5/cSL1FKmJ8osnpjJzxWb2b5/LhNH5tMwO50RE3SMRn6lIJCU557j+xVm8O28d++RmMmnscDq2yg461m5l6YpEPKYikZR03zsLeKp4GTmZaTw8Op+eHVsGHelbZdTebI/oHon4R0UiKefp4mXc+6/5pBn85dwhDNl/n6Aj7ZHukYjPVCSSUormreW3L8wE4Pc/PpTj+3UOOFH9aGhLfKYikZQxc/lmfv74VGqijp8XHMQF3zkg6Ej1tn33Xw1tiX9UJJISlm3cypjCYrZW1XD6Yftx9Q/6BB2pQTS0JT5TkUjofVVexagJk1lfVslRvTpy58iBoVtwuCcZ8YdpRaKOaFRXJeIXFYmEWkV1DRdNKmbh+nIO6dKaBy4YQlZG6v3Ymtn2bVKiuioRv6Tev0hpNmqijiuenMbUpZvo2jaHwjHDaZ2TGXSsvaZtUsRXKhIJJecct7wym7c+X0ObnAwKxw6nS9ucoGMlRPdJxFcqEgmlB99fyCOfLCErPY3xPx1G786tg46UMG2TIr5SkUjovPTZCu54fS4Afzp7EN85sEPAiZIjK11TgMVPKhIJlY8XrOeqZ6YDcP2P+nLKoK4BJ0qe2l2JqyO6IhG/qEgkNOas2sLPHp1CdY1j7JE9uXjEgUFHSqraWVsRzdoSz6hIJBRWbtrGmInFlFZG+NGAfbn+R32DjpR0dfdItHGjeEZFIoHbvK2a0RMns3pLBcN7tOdPZw8iLS21FhzWR+36F83aEt+oSCRQlZEaxj1Swvw1ZfTq1IrxPx1KTmZ60LEahab/iq9UJBKYaNRx1TMz+HTRRjq1zqZwTD7tcrOCjtVoardJ0fRf8Y2KRAJzxxtzeWX6SlplZzBxTD7d9skNOlKj2j60pXsk4peUKBIzG2lm75vZFDNbaGYlZnZh0Llk7038aBHj319IRprxwAVD6N+1bdCRGt32LVJ0RSJ+CX2RmNmVwO+A85xzQ4E+wHzg+4EGk732+sxV/P7/PgfgrjMHMuLgvIATNY26TRtVJOKZjKADfBsz6wHcARzlnFsO4JyrNrOrAH9WqjUjkxdt5Jf//Azn4Oof9OGMId2CjtRktm+RoqEt8UuoiwS4ENjknCve8aBzbiWwMphIsrcWrC3lkkdKqIpEOf/w/fl5wUFBR2pSWVrZLp4K+9DWEcDi+D2SD8xsrpl9bGZjgw4mDbN2SwWjJhSzeVs1x/XtxC2n9k+5h1MlKkNDW+KpsF+RdAd6AFcBpwNrgZHAk2a2r3Pu9l29yMzGAeMA8vLyKCoqapKwvisrK9urc7kt4vjjpxWsKI1yYNs0zupWxocfvJ/8gCG3bk0lAJ/PnUfR1oV7fT5l13Q+gxP2IskBWgJXO+dWx489Y2Y/Aa4zs3udc1t3fpFzbjwwHqBPnz6uoKCgqfJ6raioiIaey+qaKGMLi1laupUeHXJ55tIj6NAqu3EChlzRltmwbDE9DuxFwVE99+p8yu7pfAYn7ENbpfH3n+10fBqQC/Rr2jjSEM45rn1uJh98sZ4OLbOYNHZ4sy0R0BYp4q+wF8nc+Pudc9bs5riEyL1vz+e5qctpkZnOhNH5HNChZdCRAqXpv+KrsP8ifiX+fuBOxw8FtgGzmzaO1NcTny7lvn8vID3N+Nv5hzGoe7ugIwUuI03Tf8VPYS+SfwLFwG1m1grAzEYAZwK3O+fKgwwnu/bOnDVc/+JMAG477VCOPaRzwInCoXZoSyvbxTehvtnunKsxsxOBO4HZZlYBVAK/cM79I9h0siufLdvEL56YRtTBFd8/mHOH7x90pNDQ0Jb4KtRFAuCc2whcEnQO2bPF68sZW1jMtuoazhrajSuPOzjoSKGyfRt5DW2JX8I+tCUpYkNZJaMmTmZjeRVH987jD2cMaHYLDvdk+xYpuiIRv6hIJGFbqyKMnVTCkg1bOXS/Ntx//pC6X5qynbZIEV/Ve2jLzM4Cfgy0AhYBLzjnmt/yZPmaSE2Uy5+YxvRlm+i2TwsmjM6nVXboR0wDoS1SxFf1+rPRzG4iNoPqFOBAYpspFpnZVDPr04j5JMScc9zw0mzembuWdrmZTBo7nE6tc4KOFVp190iiukcifqnv+MNlwDNAB+fcQOdcR2AEUAZMNrO+jRVQwutv7y7gyclLyc5I4+FRwzgor1XQkUItU0Nb4qn6Fklb4GHnXKT2gHPuI+B7wFTgrkbIJiH23JTl3PPWfMzgzz85jKEHtA86UuhlZWhoS/xU3yJZTmwn3q9xzjngL0BBEjNJyL0/fx3XPDcDgJtP6c+Jh3YJOFFq0PRf8VV9i+QB4CYz2283H69IUh4JuVkrNnPpY1OIRB0/+96BjDqiR9CRUsb2LVJ0RSJ+qW+R3EtsX6tZZnarmX3XzLqbWQFwG6BV5s3A+m1RxhQWU15Vw48Hd+WaHxwSdKSUUju0pS1SxDf1KhLnXA2xGVt3Entg1IfAYuAdYs8LWWxmh5mZ5n16atPWKv5UUsG60kq+e2AH7jpzIGlpWnDYEBraEl/Ve9WYcy7inLsD6ELsEbi/Ah4nNnPrfqAEKDWzyY0RVIJTUV3DJY+UsKrccUiX1jz406FkZ6QHHSvlbC8SXZGIXxp8BRG/wf5p/A0AM8sFDgOGAUOSlk4CF406rvznZxQv/or2OcbEMfm0yckMOlZK0hYp4qukDEXFH3f7UfxNPOGc49ZXP+f1WatpnZPBr4Zmsm/bFkHHSlna/Vd8pQ2RZLce+mAREz9aTFZ6Gg9eOJRurfXjkojaK5KI7pGIZ/SbQXbp5ekruf21OQDcc/YgjjioY8CJUp/ukYivVCTyDZ98uYGrnp4OwHUnHcKpg7oGnMgPtbv/VmmLFPGMikS+Zt7qUsY9WkJVTZTRR/TgkhEHBh3JG5l1W6RoaEv8oiKROqs3VzB64mRKKyKc2L8LN5zcTw+nSiINbYmvVCQCwJaKakZPnMyqzRUMO2Af/vcng0nXgsOkyoifz0jUEZtFL+IHFYlQFYnyX49OYe7qUg7Ka8lDo4aRk6kFh8lmZjtMAVaRiD9UJM1cNOr4zbPT+fjLDeS1zqZwzHDa5WYFHctbGt4SH6lImrm73pzHi5+tpGVWOhNH59O9fW7QkbymIhEfqUiasUc+Wczf3/uSjDTjgQuGcuh+bYOO5D1tkyI+UpE0U2/OXs1NL88G4I9nDODo3nkBJ2oedI9EfJRyRWJmH5iZM7MeQWdJVVOWfMUVT07DOfjV8b05a9g3Hn4pjWT7Nim6IhF/pFSRmNlI4Kigc6SyL9eVcdGkYiojUc4d3p3Lj+0VdKRmRRs3io9SpkjMLAv4I/Ba0FlS1drS2ILDTVurOfaQTtz640O14LCJ1d0jiWhoS/yRMkUCXEbs4VnFQQdJReWVES4qLGHZxm0M6taWv553GBnpqfS/3w9ZGZq1Jf5Jid8kZtYeuBq4Lugsqai6JsplT0xl5orNHNAhl4dH55ObpaciB6F2dbuKRHySEkUC3Ag85pxbHHSQVOOc4/oXZlE0bx3tW2YxacxwOrbKDjpWs6XntouPQv9nqZn1As4G+jbgNeOAcQB5eXkUFRU1TrgU8OKCKl5cUE1WGlw2II3Fs4pZvJdfq6ysrFmfy2Qo27INgCnTptEjp0LnM4n08xmc0BcJcBdwh3Nuc31f4JwbD4wH6NOnjysoKGikaOH2dPEyXlwwgzSD+y8YxnH9Oif09YqKimiu5zJZHllczOwNa+nbfwDpa+bofCaRfj6DE+oiMbMRwKHAOUFnSTXvzl3Lb1+YCcCtpx2acIlIcuw4/VfbYoovQl0kwPFAOlC8wzTVLvH3r5lZFXCdc05TgncwY/kmfv74VGqijsuOOYjzDz8g6EgSt32LFEdOwFlEkiXUReKcu5HYjfY6ZnYzcBNwkm6+f9PSDVsZW1jMtuoazhiyH1ed0CfoSLKDupvtetyueCRVZm1JPWwsr2LUxMmsL6viqF4dueOMgVpwGDK1Q1uRqIpE/JEyRWJmJ5nZZ8B/xQ+9Fv9vAbZV1XDRpGIWrS+n775teOCCIXWL3yQ8dhzaEvFFqIe2dhS/D6J7IbtQE3Vc8dQ0pi3dxH7tWlA4Jp/WOZlBx5Jd0NCW+Eh/sqY45xw3vzybtz9fQ5ucDCaNzadzG93GDSttkSI+UpGkuAfe+5JH/7OErIw0HhqVT69OrYOOJN9CW6SIj1QkKeyFacu56415mMH/njOY4T3bBx1J9kBbpIiPVCQp6qMF6/nNszMAuOFH/ThpwL4BJ5L60NCW+EhFkoI+X7mFnz06heoaxyUjejL2qJ5BR5J60oOtxEcqkhSzYtM2xhROpqwywskD9+W3P6z3XpYSAhraEh+pSFLI5q3VjJ4wmTVbKjm8Z3v+dPYg0tK04DCVbF9HoisS8YeKJEVUVNdwyaMlfLG2jN6dWzH+wmFkZ2jbv1RTt7JdRSIeUZGkgGjU8etnpjN50UY6t8mmcMxw2uZqwWEq0tCW+EhFkgL+8NocXp2xilbZGRSOGU7Xdi2CjiR7SUNb4iMVScg9/OEiHvpwEZnpxoMXDqXvvm2CjiQJ0BYp4iMVSYi9OmMVt736OQB3nTmQI3t1DDiRJCorQ9N/xT8qkpD6dOEGrvznZzgHvzmxD6cf1i3oSJIEGWm6RyL+UZGE0BdrSrnkkRKqaqJc+J0DuPR7BwUdSZJk+812XZGIP1QkIbNmSwWjJxazpSLC8f06c/Op/fVwKo9oaEt8pCIJkdKKakZPLGbFpm0ctn877vvJYaRrwaFXNP1XfKQiCYmqSJRLH5vKnFVb6NmxJQ+PyqdFlhYc+kZDW+IjFUkIOOe49rkZfLhgPR1bZTFpzHDat8wKOpY0gtqV7VpHIj5RkYTAPW/N4/lpK8jNSmfC6Hz275AbdCRpJLVXJBENbYlHVCQBe+w/S/jbu1+Snmb87fwhDOzWLuhI0og0tCU+UpEE6O3P13DjS7MA+MPph3JMn04BJ5LGpiIRH6lIAjJ16Vdc/uRUog5++f2DOSd//6AjSRPIqt1rS1ukiEdUJAFYtL6ciyeVUFEd5exh3fjv4w4OOpI0kcy6dSS6RyL+UJE0sfVllYyaMJmN5VV8r3cet58+QAsOm5HtW6ToikT8kRF0gD0xs8HAZcAQYnkzgX8Btzrn1gWZraG2VkW4qLCYpRu3MmC/ttx//pC6MXNpHuoebBV1OKerEvFDKvwWewpoDxztnBsEHA+cAHxkZinzYI5ITZRfPDGN6cs30719CyaMzqdlduh7XJLMzOrKRKNb4otUKBKAa5xz5QDOuRXA3cDBwEmBpqon5xw3vDSLf89dyz65mUwaM5y81tlBx5KA1K0l0eiWeCIV/iQe6Jyr2unYyvj7fZo6zN74y78X8OTkZWRnpPHQqHwOzGsVdCQJUKxIalQk4o3QX5HsokQAegMOeL+J4zTYMyXL+J+355NmcN+5hzH0gJToPmlEdfdJdI9EPBH6ItmZmaUDY4GHnXPzg87zbd6bv47fPj8TgJtP7c8P+ncJOJGEQe3QliZuiS9SYWhrZzcAEeDK3X2CmY0DxgHk5eVRVFTUNMl2sHhzDXdMriAShZN6ZrJ/5WKKihY3eY5kKisrC+Rc+iZSVQnAlrKtOp9JpJ/P4KRUkZjZGOBsoMA5V7a7z3POjQfGA/Tp08cVFBQ0TcC4ZRu3cvUDH1NRA6cN7sr/nD2YNA+eK1JUVERTn0sftZlSxLpt5WS3yNX5TCL9fAYnZYa2zOxC4NfAsc65tUHn2Z2vyqsYNXEy60orOeKgDtx15iAvSkSSZ/usLd0jET+kRJGY2QXANcBxzrnV8WMnx4ewQqOiuoaLHylh4bpyDunSmr9fOJSsjJQ4xdKEan8mIuoR8UToh7bM7HzgH8TujRy3w3YiI4BVQeXaWU3U8cunpjFlyVfs2zaHwjHDaZOTGXQsCaGM+BWqbraLL0JfJMBfgBxiixB3dksTZ9kl5xy/f2U2b85eQ+ucDCaNHU6XtjlBx5KQ0oJE8U3oi8Q51z7oDHsy/v2FTPpkCVnpaYy/cBi9O7cOOpKEWO3QVo3WkYgnNICfoJc+W8EfX58LwD1nD+K7B3UIOJGEna5IxDcqkgR88uUGrnpmOgC/O6kvpw7qGnAiSQXbdwAOOIhIkqhI9tLc1VsY92gJ1TWO0Uf04OIRPYOOJCkiI12ztsQvKpK9sGrzNkZPKKa0IsIPD+3CDSf308OppN6y6rZIUZOIH1QkDbSloprRE4pZvaWC/B77cO85g0nXgkNpgO2bNgYcRCRJVCQNUBmp4WePTGHemlIOymvJP346jJzM9KBjSYrRpo3iGxVJPUWjjqufmcEnCzeQ1zqbwjHDaZebFXQsSUGatSW+UZHU051vzuXl6StpmZVO4Zh8urfPDTqSpCg9j0R8oyKph0kfL+bB9xaSkWb8/cKh9O/aNuhIksI0tCW+UZHswRuzVnPzK7MBuHPkQEYcnBdwIkl1GtoS36hIvsWUJRv55VPTcA6uOqE3I4d2CzqSeGD7FikBBxFJEhXJbny5royLJpVQGYly3uH7c9kxvYKOJJ7YvrJdTSJ+UJHswtrSCkZNmMymrdUc17cTvz+1vxYcStJoaEt8oyLZSVllhLGFxSz/ahuDurfjvnMPq9vSQiQZan+eNLQlvtBvyB1U10S57PGpzFqxhR4dcpkwahi5WaHfaV9STJY2bRTPqEjinHP87oWZvDd/HR1aZlE4ZjgdWmUHHUs8VDe0pXUk4gkVSdy9//qCp0uWk5OZxsOj8+nRsWXQkcRTWkcivlGRAE9OXsp973xBmsFfzx3C4O7tgo4kHtPNdvFNsy+Sf89dw/UvzgLgttMGcFy/zgEnEt9p91/xTbMukunLNnHZ49OoiTouP7YX5x2+f9CRpBnI1PNIxDPNtkiWbChnbGEx26prGDmkG786vnfQkaSZ0NCW+KZZFsmGskpGTZjMhvIqRhzckTtGDtCCQ2kyWRmxnzWtIxFfNLsi2VZVw0WTSli8YSv9u7bhgQuG1v2FKNIUdEUivmlWv0EjNVEuf3Iany3bxH7tWjBxdD6tsrXgUJpWRlptkeiSRPzQbIrEOcfNr8zmX3PW0LZFJpPG5tOpTU7QsaQZ0tCW+Cb0RWJmnczscTObF3971swavJ/7/UVf8th/lpKVkcbDo4bRq1Prxogrskca2hLfhLpIzCwLeBvIAvoD/YBy4F0za1Xfr/P81OXc/eY8zODP5wxmWI/2jRNYpB4ytWmjeCbURQKMAgYC1zjnIs65GuAa4EDg0vp8gW0R+M2zMwC48eR+/HDAvo2VVaRetl+RqEnED2EvkpHAUufcwtoDzrnVwOfxj+3R2q1RIlHHuKMPZMyRPRsppkj9ZWloSzwT9ilLA4H5uzi+CPh+fb6AA04Z1JVrTzwkmblE9lpGfIuUihq4/MlpAafxx9o1FTy3SuczCGEvko7AlF0c3wLkmlkL59y2nT9oZuOAcQC5nXtwaudNvP/+e42btBkoKyujqKgo6BgpL+ocLTOhvBpemb4y6Dh+Wa3zGYSwF8nufOsydOfceGA8wMG9+7jjjz2mSUL5rqioiIKCgqBjeOGl/mU8+6//0Ldf36DmN30QAAAF7klEQVSjeGPO53N0PpPktDsb9vlhL5L1wK7m6bYGtu7qamRnadr5REKoV6dWfKdrBgWD9ws6ijfabvpC5zMgYb/ZPgPosYvjPYGZTRtFRER2JexF8jxwgJn1qD1gZp2BvsBzAWUSEZEdhL1IColdedxpZhlmlgbcQWzW1gNBBhMRkZhQF4lzrgo4HqghtnZkDtAGONY5VxZkNhERiQn7zXacc2uA84LOISIiuxbqKxIREQk/FYmIiCTEnPN74zgzKwXmBZ3DEx2Jre2R5ND5TC6dz+Tp45yr97M2Qn+PJAnmOeeGBR3CB2ZWonOZPDqfyaXzmTxmVtKQz9fQloiIJERFIiIiCWkORTI+6AAe0blMLp3P5NL5TJ4GnUvvb7aLiEjjag5XJCIi0ohUJLJHZravmb1hZrp8FWkmzOwDM3M7bpq7O14WiZl1MrPHzWxe/O1ZM+sWdK5UZGanA58ABwWdJdWZ2WAz+4eZTTGz6Wb2uZndZ2Z5QWdLRWZ2kJndEz+fU8xsfvyX34+CzpbqzGwkcFR9P9+7IjGzLOBtIAvoD/QDyoF3zaxVkNlS1LXENs78KOggHngKaA8c7ZwbROy8ngB8ZGYtAk2Wmn4I/AQ4xzk3FDiE2B89L5vZ9wJNlsLiv0P/CLxW39d4VyTAKGAgcI1zLuKcqwGuAQ4ELg00WWo60jn3RdAhPHKNc64cwDm3ArgbOBg4KdBUqWkFcLNzbgGAcy4K/IHY77UfBxksxV0GlADF9X2Bj0UyEljqnFtYe8A5t5rYNvQjA0uVopxzkaAzeGRg7S+9HayMv9+nqcOkOufcC865h3Y63Cb+fl1T5/GBmbUHrgaua8jrfCySgcQefLWzRcCAJs4iUif+fJ2d9QYc8H4Tx/GOme0H/A2YGn8vDXcj8JhzbnFDXuRjkXQESndxfAuQq7FoCQszSwfGAg875+YHnSdVxW+6LwCWA+nAac65LQHHSjlm1gs4G7i9oa/1sUh2x4IOILKTG4AIcGXQQVKZc+5L51wvoC0wH5huZvWecSR17gLucM5tbugLfSyS9cCutj9uDWx1zm1r4jwi32BmY4j99fdDPTY6OeJXIVcCa4D7A46TUsxsBHAo8MDevN7HbeRnEJsGuLOewMwmziLyDWZ2IfBr4Fjn3Nqg86Sq+DB1hdthnyfnnDOzmcCZZpbtnKsMLmFKOZ7YsGCxWd3gTZf4+9fMrAq4zjm3yynBPl6RPA8csONqTDPrDPQFngsokwgAZnYBsenox8VnE2JmJ5vZuGCTpaTXge/s4ngPYvdEdzW5QXbBOXejc+4g59zg2jfg7/EPnxQ/ttt1JT4WSSGxK487zSzDzNKAO4jN2tqryzaRZDCz84F/EPsZPc7MLogXyylA1yCzpbBbzKwDgMVcDuQD9+14pSKNy8vdf+NXIPcCw4hNrZwF/LdzblmgwVKQmd1N7LJ3f2JrHabHPzR8N9NZZTfMbCO7Xy9yi3Pu5iaMk/LM7EjgYmLFEQFygA3E7o88oSLZO2Z2ErGFnV2AzsAcoCp+lbLr1+hci4hIInwc2hIRkSakIhERkYSoSEREJCEqEhERSYiKREREEqIiERGRhKhIREQkISoSERFJiIpEREQSoiIREZGEqEhERCQhKhKRJmJmvcys2sxu2en4A2ZWambDgsomkggViUgTcc4tAB4CrjSzjgBmdiOx57af7pwrCTKfyN7S7r8iTcjMugBfEtvqfC4wHjjXOfd0oMFEEuDjo3ZFQss5t9rM/pfYo3YzgCtUIpLqNLQl0vS+ALKBT5xzfws6jEiiVCQiTcjMjgUeBD4BjjSzQQFHEkmYikSkiZjZEOBFYjfcC4ClxB5pKpLSVCQiTcDMegGvA28Bl8efd38LcJKZHR1oOJEEadaWSCOLz9T6mNgVyA+cc5Xx4+nALOAr59wRAUYUSYiKREREEqKhLRERSYiKREREEqIiERGRhKhIREQkISoSERFJiIpEREQSoiIREZGEqEhERCQhKhIREUmIikRERBLy/7mXPz6jAa7sAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the initial car density on the road.\n", + "pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel(r'$x$')\n", + "pyplot.ylabel(r'$\\rho$')\n", + "pyplot.grid()\n", + "pyplot.plot(x, rho0, color='C0', linestyle='-', linewidth=2)\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(-0.5, 11.0);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**How does the traffic behave once the light turns green?** Cars should slowly start moving forward: the density profile should move to the right. Let's see if the numerical solution agrees with that!\n", + "\n", + "Before we start, let's define a function to calculate the traffic flux. We'll use it in each time step of our numerical solution." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def flux(rho, u_max, rho_max):\n", + " \"\"\"\n", + " Computes the traffic flux F = V * rho.\n", + " \n", + " Parameters\n", + " ----------\n", + " rho : numpy.ndarray\n", + " Traffic density along the road as a 1D array of floats.\n", + " u_max : float\n", + " Maximum speed allowed on the road.\n", + " rho_max : float\n", + " Maximum car density allowed on the road.\n", + " \n", + " Returns\n", + " -------\n", + " F : numpy.ndarray\n", + " The traffic flux along the road as a 1D array of floats.\n", + " \"\"\"\n", + " F = rho * u_max * (1.0 - rho / rho_max)\n", + " return F" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Forward-time/backward-space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Start by using a forward-time, backward-space scheme, like you used in Module 2. The discretized form of our traffic model is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\rho^{n+1}_i- \\rho^n_{i}}{\\Delta t}+ \\frac{F^n_{i}-F^n_{i-1}}{\\Delta x}=0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Like before, we'll step in time via a for-loop, and we'll operate on all spatial points simultaneously via array operations. In each time step, we also need to call the function that computes the flux. Here is a function that implements in code the forward-time/backward-space difference scheme:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def ftbs(rho0, nt, dt, dx, bc_value, *args):\n", + " \"\"\"\n", + " Computes the history of the traffic density on the road \n", + " at a certain time given the initial traffic density.\n", + " \n", + " Parameters\n", + " ----------\n", + " rho0 : numpy.ndarray\n", + " The initial car density along the road\n", + " as a 1D array of floats.\n", + " nt : integer\n", + " The number of time steps to compute.\n", + " dt : float\n", + " The time-step size to integrate.\n", + " dx : float\n", + " The distance between two consecutive locations.\n", + " bc_value : float\n", + " The constant density at the first station.\n", + " args : list or tuple\n", + " Positional arguments to be passed to the flux function.\n", + " \n", + " Returns\n", + " -------\n", + " rho_hist : list of numpy.ndarray objects\n", + " The history of the car density along the road.\n", + " \"\"\"\n", + " rho_hist = [rho0.copy()]\n", + " rho = rho0.copy()\n", + " for n in range(nt):\n", + " # Compute the flux.\n", + " F = flux(rho, *args)\n", + " # Advance in time.\n", + " rho[1:] = rho[1:] - dt / dx * (F[1:] - F[:-1])\n", + " # Set the left boundary condition.\n", + " rho[0] = bc_value\n", + " # Record the time-step solution.\n", + " rho_hist.append(rho.copy())\n", + " return rho_hist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We're all good to go! \n", + "\n", + "**Note:** The code above saves the complete traffic density at each time step—we'll use that in a second to create animations with our results. \n", + "\n", + "Running the numerical solution is easy now: we just need to call the function for evolving the initial condition with the forward-time/backward-space scheme.\n", + "\n", + "Let's see how that looks." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the time-step size based on CFL limit.\n", + "sigma = 1.0\n", + "dt = sigma * dx / u_max # time-step size\n", + "\n", + "# Compute the traffic density at all time steps.\n", + "rho_hist = ftbs(rho0, nt, dt, dx, rho0[0], u_max, rho_max)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's now create an animation of the traffic flow density using the `animation` module of Matplotlib." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import animation\n", + "from IPython.display import HTML" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the initial traffic density.\n", + "fig = pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel(r'$x$')\n", + "pyplot.ylabel(r'$\\rho$')\n", + "pyplot.grid()\n", + "line = pyplot.plot(x, rho0,\n", + " color='C0', linestyle='-', linewidth=2)[0]\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(-0.5, 11.0)\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def update_plot(n, rho_hist):\n", + " \"\"\"\n", + " Update the line y-data of the Matplotlib figure.\n", + " \n", + " Parameters\n", + " ----------\n", + " n : integer\n", + " The time-step index.\n", + " rho_hist : list of numpy.ndarray objects\n", + " The history of the numerical solution.\n", + " \"\"\"\n", + " fig.suptitle('Time step {:0>2}'.format(n))\n", + " line.set_ydata(rho_hist[n])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create an animation of the traffic density.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(rho_hist,),\n", + " interval=100)\n", + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Yikes! The solution is blowing up.** This didn't happen in your traffic-flow exercise (coding assignment) for Module 2! (Thankfully.) What is going on? Is there a bug in the code?\n", + "\n", + "No need to panic. Let's take a closer look at the equation we are solving:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial \\rho}{\\partial t} + \\frac{\\partial F}{\\partial x} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Using the chain rule of calculus, rewrite is as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial \\rho}{\\partial t} + \\frac{\\partial F}{\\partial \\rho} \\frac{\\partial \\rho}{\\partial x} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This form of the equation looks like the nonlinear convection equation from [Lesson 1 of Module 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_01_1DConvection.ipynb), right? This is a wave equation where the wave speed is $u_{\\rm wave} = \\frac{\\partial F}{\\partial\\rho}$. That term is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u_{\\rm wave} = \\frac{\\partial F}{\\partial \\rho} = u_{\\rm max} \\left( 1-2\\frac{\\rho}{\\rho_{\\rm max}} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "See how the wave speed changes sign at $\\rho = \\rho_{\\rm max}/2$? That means that for the initial conditions given for the green-light problem, the part of the wave under $\\rho = \\rho_{\\rm max}/2$ will want to move right, whereas the part of the wave over this mark, will move left! \n", + "\n", + "There is no real problem with that in terms of the model, but a scheme that is backward in space is *unstable* for negative values of the wave speed. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Upwind schemes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Maybe you noticed that the backward-space discretization is spatially biased: we include the points $i$ and $i-1$ in the formula. Look again at the stencil and you'll see what we mean." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![FTBS_stencil](./figures/FTBS_stencil.png)\n", + "#### Figure 4. Stencil of forward-time/backward-space." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In fact, the spatial bias was meant to be in the direction of propagation of the wave—this was true when we solved the convection equation (with positive wave speed $c$), but now we have some problems. Discretization schemes that are biased in the direction that information propagates are called _upwind schemes_.\n", + "\n", + "Remember when we discussed the characteristic lines for the linear convection equation in [lesson 1 of the previous module](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_01_1DConvection.ipynb)? Compare the sketch of the characteristic lines with the stencil above. The point is that there is an inherent directionality in the physics, and we want the numerical scheme to have the same directionality. This is one example of _choosing an appropriate scheme_ for the physical problem.\n", + "\n", + "If we wanted to solve the convection equation with negative wave speed, $c<0$, we would need a spatial bias \"slanting left,\" which we would obtain by using the points $i$ and $i+1$ in the formula.\n", + "\n", + "But if we have waves traveling in both directions, we are in a bit of a bind. One way to avoid this problem with our traffic flow model is to simply use an initial condition that doesn't produce negative speed. This should work. But later we will learn about other numerical schemes that are able to handle waves in both directions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just for a sanity check, let's try the forward-time/backward-space scheme with the initial conditions\n", + "\n", + "\\begin{equation}\\rho(x,0) = \\left\\{ \\begin{array}{cc}\n", + "2.5 x & 0 \\leq x < 2 \\\\\n", + "0 & 2 \\leq x \\leq 4 \\\\ \\end{array} \\right.\\end{equation}\n", + "\n", + "If all values of $\\rho \\leq \\rho_{\\rm max}/2$, then $\\frac{\\partial F}{\\partial \\rho}$ is positive everywhere. For these conditions, our forward-time/backward-space scheme shouldn't have any trouble, as all wave speeds are positive." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAELCAYAAAAP/iu7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl8VfWd//HXh6wkQNgi+w6JWkQRdNoqEhBQaala2tpptbZOxbZo3ei0nf6qtR1nnCroaFuL3TttR21r1U5dWCQugAJxr5iwIyD7koSQ5eZ+fn/cJAUEvGDOPXd5Px+PPALnnnvvJ1/gvjnf8z2fY+6OiIhIkDqEXYCIiKQ/hY2IiAROYSMiIoFT2IiISOAUNiIiEjiFjYiIBE5hIyIigVPYiIhI4BQ2IiISuOywCwha165dffjw4WGXkXb2799PYWFh2GWkHY1rMDSuwaioqNjp7sXx7Jv2YdOrVy9WrFgRdhlpp7y8nLKysrDLSDsa12BoXINhZhvi3VfTaCIiEjiFjYiIBE5hIyIigVPYiIhI4BQ2IiISOIWNiIgELu2XPotI8qiurmb79u00NTUl9H2LiopYuXJlQt8zVWVnZ5Ofn09xcTH5+fnt97rt9koiIsdQXV3Ntm3b6NevHx07dsTMEvbeNTU1dO7cOWHvl6rcnUgkQm1tLRs3bqRXr14UFRW1y2srbEQkIbZv306/fv0oKCgIuxQ5CjMjJyeHbt26kZeXx9atW9stbHTORkQSoqmpiY4dO4ZdhsSpY8eONDQ0tNvrhRo2ZtbHzJ4yMw+zDhFJjEROnckH095/VqGFjZldCiwFhr3Pfjlm9gMze9vM3jSzJWZ2bmKqFBGR9hDmkc23gMnA4vfZ7z7gMmCcu48EfgnMN7MzAq5PRETaSZhhc467rzrWDmZWCswA7nD3HQDu/nNgLXB78CWKiEh7CC1s3D0Sx26XAgYsOmz7M8AUM+vU7oWJiEi7S/bVaKOAKLDxsO3riC3bPjXhFYmIJLF3332XDh06sHjxYv70pz8xffp0Bg0aRMeOHSktLeXb3/42NTU1Ca8r2a+z6QnUuXvzYdurW773ONKTzGwGsek3iouLKS8vD6zATFVbW6txDUA6j2tRUVEoH3IAzc3Nob13oj344IP07NmTkSNHcsMNNzBgwAC++93v0q9fP1577TXuuOMOFixYwIIFC+jQ4djHG/X19e329zHZw+Zojrkmz90fAB4AKC0tdd2hr/3pzofBSOdxXblyZWhX8WdSB4GnnnqKiy++mKKiIp544gmKi/9x1+aLLrqIvn37cuWVV1JRUcHEiROP+Vr5+fmMHj26XepK9mm0nUCBmWUdtr31b82uBNcjIvIekUiEu+66i6FDh5Kbm0txcTHf+973El5HdXU15eXlXHLJJQCHBE2rs846C4DNmzcntLZkD5vXidU44LDtQ4AIoM56IhKqpqYmpk2bxj333MO3vvUtHn/8ccrKyrjtttt46KGHElrL3/72N3Jzc5k0adJR93n22WcBOOWUUxJVFpD8YfMXwIGyw7ZPAOa5e2ZMwoqkMTM76tcDDzzQtt8DDzxwzH0PNmbMmEMe69KlS9uvZ8yY0bZfRUXFB65/9uzZLFmyhCVLljBjxgwuvPBC/vCHP9C5c2cee+yxD/z6x+PRRx/lwgsvJC8v74iPb968mVtuuYVJkyYxduzYhNaW1GHj7pXEzr1828x6ApjZVcS6DnwnzNpERKLRKHPmzGHmzJkMHDiwbXtOTg6DBg2itrY2YbU0Njby1FNPtU2hHa62tpaLL76Y7OxsfvWrXyWsrlahLRAwszuJdRAY2PL7V1seOtvdGw/a9TrgVmCxmTUBNcAUd38VEUl57vG1RpwxY8YhRyXHcvgRy9EWCIwZMyau1zuaZcuWsWPHDj72sY8dst3d2bJly/uegG9PCxcu5MCBA++pBWKryj7xiU+wdu1ann32Wfr375+wulqFeVHnN9z9DHfv7u7W8uszDgsa3L3J3f+fu5e6+0h3/4i7Px9W3SIirV588UWA93x4L1myhN27d7cdZdxyyy189rOfZdq0aQwdOpRLLrmEV199lY9//OMMHTqUK664ou25FRUVnHfeeYwZM4bhw4fzgx/8AIBrrrmGWbNmAbBlyxZOPfVUFixY0Pa8Rx99lPHjx9O1a9dDamlqamL69OksW7aMJ554gtNOO639ByIe7p7WXyUlJS7tb9GiRWGXkJbSeVzfeuut0N67uro6kNe9/PLLHfCFCxe2bWtubvZx48b5qFGjvLm52d3dp06d6tOmTfO6ujpvaGjw4uJi/+IXv+j19fV+4MABLyoq8i1btri7++7du72pqcnd3evq6rxnz56+e/du37ZtmxcXF3tFRYWffvrp/vjjj7e9ZzQa9T59+viPfvSjQ+prbm72T3/6056Xl+cLFiw47p/v/f7MgBUe52dxql5nIyISuoqKCvr378/XvvY1br/9dsyM++67j1deeYWXXnqp7aLJiooKysvL2+7nE4lE+P73v09eXh7Nzc1EIhG6dOkCxK6TmTt3Lnv27MHd2bt3L7m5uXTr1o1rr72Wc845h9/85jdMmzatrY4XX3yRd999l4svvviQ+mbOnMkf//hHvvOd71BYWNh2JAaxo7FETqcpbERETsD+/fuprKzkxz/+MevXr+eaa67hwIEDjB8/nqVLl3LqqbFuWps2bSIajXLyyScDsG7dOrp27cqAAbErOlauXMnAgQMpLCzkb3/7G3fffTePPfYYffr04ZlnnmHmzJkUFhaya9cuHnnkEYqKitqe2+rRRx9l7Nix7wmPJ598EoDbb7+d228/tHfxrbfemtBrgRQ2IiIn4JVXXiEajXLWWWfxla98hTvuuOOI+1VUVByyzHj58uWH/P7gxysqKjjjjDPo06cPO3bs4F//9V8566yz2LdvHxdeeCGzZs0iOzubm266iaVLl7a9xmOPPXbIeZ9W69evb6ef9oNT2IiInICKigpyc3Pf94T74WGzYsWKo4bNF77wBS6++GJGjRrFqFGjGDx4MGPGjGHq1Kl8+ctf5vLLL8fdmT17Ng8++CCf/exnAXj77bcD+Anbl8JGROQEVFRUMHLkSHJzc4+53/e///1Dfv/DH/7wkN/fe++9bb8ePHgwr7322nte4/rrr2/7tZmxfPnyEyk5VAobEZET8Nvf/jbsElJKUncQEBGR9KCwERGRwClsREQkcAobEUkYj7MPmoSvvf+sFDYikhDZ2dlEIpGwy5A4NTU1kZV1+H0rT5zCRkQSIj8/P6Et9+WDqa6ubtdbaStsRCQhiouL2bFjB3V1dZpOS1LuTmNjIzt37mTPnj1079693V5b19mISELk5+fTq1cvtm7dSkNDQ0Lfu76+nvz8/IS+Z6rKysqic+fODBw48Kh3/DwRChsRSZiioiKKiooS/r7l5eWMHj064e8r/6BpNBERCZzCRkREAqewERGRwClsREQkcAobEREJnMJGREQCp7AREZHAJX3YmNlYM3vSzFaa2RtmtszMPh12XSIiEr+kDhszGwwsBHYCp7n7acAvgYfNbFqIpYmIyHFI6rABpgJdgDnuHgFw958C1cDnwixMRETil+xh09qPvK2tjpkZsbrbr/e1iIgEypK5+6qZdQFeAqqAzwN1wLeBW4EL3f2ZozxvBjADoLi4eMzDDz+cmIIzSG1tLZ06dQq7jLSjcQ2GxjUYEyZMqHD3sfHsm9RhA2BmfYFfAeOBWmAfcJW7PxvP80tLS72ysjLACjNTeXk5ZWVlYZeRdjSuwdC4BsPM4g6bpJ5GM7NSYBmwAegOnAR8B3jEzC4KszYREYlfUocN8AOgK3C9u9e5e9TdHwSeA35jZrpFgohICkj2sDkN2OTuBw7bXgUUA0MSX5KIiByvZA+b7UCfIxzBDAIc2JP4kkRE5Hgle9jcR+w6m++3LHnGzCYAnwQecvedYRYnIiLxSepzHu7+JzO7EPgW8JaZNQNRYosE7g21OBERiVtShw2Auz8NPB12HSIicuKSfRpNRETSgMJGREQCp7AREZHAKWxERCRwChsREQmcwkZERAKnsBERkcApbEREJHAKGxERCZzCRkREAqewERGRwClsREQkcAobEREJnMJGREQCp7AREZHAKWxERCRwChsREQmcwkZERAKnsBERkcApbEREJHAKGxERCZzCRkREApcSYWNm083sOTOrMLO1ZrbCzK4Iuy4REYlP0oeNmd0IfAf4nLuPAUqBKuD8UAsTEZG4ZYddwLGY2WDgDuBcd98E4O5NZjYL6BtiaSIichySOmyAK4C97r784I3uvgXYEk5JIiJyvJJ9Gu2jwPqWczbPm9nbZrbEzK4KuzAREYmfuXvYNRyVmb0JDAbeAC4FtgPTgf8FbnX324/yvBnADIDi4uIxDz/8cELqzSS1tbV06tQp7DLSjsY1GBrXYEyYMKHC3cfGs2+yh81qYBgwzt1fOGj7n4ELgWJ3rzvWa5SWlnplZWWwhWag8vJyysrKwi4j7Whcg6FxDYaZxR02yT6NVtPy/dXDtr8CFACnJrYcERE5EckeNm+3fD+8zuajbBcRkSSU7B/Wf235Puqw7SOBA8DfE1uOiIiciGQPm4eA5cC/m1knADMbB3wKuN3d94dZnIiIxCepr7Nx92YzuxD4L+DvZlYPNADXuvvPwq1ORETildRhA+Duu4Grw65DREROXLJPo4mISBpQ2IiISODinkYzs08DFwOdgHXAX9z9uaAKExGR9BHXkY2Z3UpsZdg0YCixBpnlZvaymZUGWJ+IiKSBeKfRZgJ/BHq4+yh37wmMA2qBZWZ2SlAFiohI6os3bIqAX7h7pHWDuy8GxgMvAz8MoDYREUkT8YbNJmDA4Rs91sXzPqCsHWsSEZE0E2/Y3A/camb9jvJ4fTvVIyIiaSje1Wh3A+cDb5rZj4AniB3tDAP+HdDV/CIicnTuHtcXsWD6FrCNWNfl1q8NxG5UNhrIjvf1EvUF+NG+5s6d663mzp171P1iw/QPZ5555lH3u/rqq9v2W7FixTFfc8WKFW37Xn311Ufd78wzzzzk/fUz6WfSz6SfKUl+phUe52dx3Bd1unvE3e8AehO7XfNNwO+JrUj7CbACqDGzZfG+poiIZIZ2uVOnmRUQO7IZC5zp7ld+4BdtJ7pTZzB058MT98amfcyZX0nVtlr+/NWP0rsov+0xjWswNK7BOJ47dbZLI06P3Zp5ccuXiBxB5dYa5syv5Om/b2vb9ubmfYeEjUi6SvquzyKpbt3O/dyzoIrHX9uCO+TndKCoYw7bqhvY3xh5/xcQSQMKG5GAbN57gHsXrOJPL2+iOerkZBn/fPZArp0wnDnzq3hw+Tvsb2h+/xcSSQMKG5F2tr2mnp8sWsMfXtpIY3OUrA7GZ8b25+vnj6B/twIACvNi//T2N+jIRjKDwkaknezZ38hPn1vDb5asp74pihl84vS+3DBpBEOLOx2yb1vYaBpNMoTCRuQDqqlv4hcvrOMXz6+jpuVIZcqpvbhpSgkn9+5yxOcU5mYBOrKRzKGwETlBdY0Rfrt0Az99dg1765oAOK+kmJsnl3D6gK7HfG7rkU2tztlIhlDYiBynhkgz//vSRn60aA07axsAOHtwd2ZdUMrZQ7rH9RqdWsKmTtNokiEUNiJxamqO8ueKTdy7cBVb9sV6z57ev4ibp5QybkRPzCzu1yrQNJpkGIWNyPtojjr/9/oW7p5fxfpddQCc3LszN00uYfKpvY4rZFp1aptGU9hIZki5sDGz54FzgSHuvj7kciSNuTtP/30bd8+vonJbDQBDehZy4+QSPn5aHzp0OP6QaVXYNo2mczaSGVIqbMxsOrGgEQmMu/Ns1Q5mz6vijc37AOjXtSPXnz+CT57Zj+ysuPvXHlVhXmwaTUc2kilSJmzMLBf4T2L30pkacjmSpl5cu4vZ8ypZvn4PAMWd87hu4nAuO2sAedlZ7fY+uqhTMk3KhA0wk9htDKpQ2Eg7e/WdvcyeV8nzq3YC0K0gh6+MH8YXPjKYjrntFzKt2qbRtPRZMkRKhI2ZdQe+Qew+Ol8MtxpJJyvfrWb2vCoWrIx1Yu6cl82Xxw3lqnMH0zk/J7D3LchpWY3WGMHdT2iRgUgqSYmwAW4Bfufu6/WPUtrDmh213D2/iv97/V0AOuZk8cVzBnPNeUPpWpAb+PtnZ3UgP6cD9U1RDjQ1U5CbKv8URU5M0v8NN7PhwGeAU47jOTOI3aqa4uJiysvLgykug9XW1qbkuO6oi/LYmiYWb47gQLbBhIHZfHxoLkV5W3l12daE1ZJrUeqB+Yuepygv9p+oVB3XZKdxDV/Shw3wQ+AOd98X7xPc/QHgAYjdqVN36Gt/qXbnw23V9dz3zCoeWv4OTc1Odgfj02MHcN3E4fTt2jGUmrouW0T17jpOH3M2g3sWAqk3rqlC4xq+pA4bMxsHjAQuC7sWSU27ahu4v3wN//PiBhoisU7Ml47uxw2TRjCoR2GotRXqwk7JIEkdNsBkIAtYftC5mt4t358ws0bg39z9iTCKk+S170ATP39+Lb98YR37Wy6cvGhkb26aXMKIXp1Dri6mU8u1NrqwUzJBUoeNu99CbHFAGzP7HnArMFUdBORw+xsi/HrJeuY+u4bq+tgRQ1lpMbOmlDKyX1HI1R2qdVGArrWRTJDUYSMSr/qmZn7/0kbuL1/NztpGAD4ytAezLihhzKD4OjEnmvqjSSZJmbAxs6nAf3DYNJq7nxFiWRKyxkiUP1a8w30LV7O1OtaJefTArnxjSikfHd4z5OqOrbBtGk1hI+kvZcKm5byMzs0IEOvE/Ogrm7lnYRXv7D4AwCl9ujBrSgkTTz4pJS6SbJ1G0w3UJBOkTNiIAESjzpNvbmXO/ErW7NgPwNDiQm6aXMLUkR+sE3OidVJ/NMkgChtJCe7OM29vZ/a8Kt56txqA/t1inZgvHd0+nZgTra0Zp6bRJAMobCTpLVm9kzvnVfLKxr0A9OqSx7UTR3DZ2AHkZqdeyLRqPWejIxvJBAobSVoVG/Zw19OVLF27C4Aehbl8tWwYl394EPk57d+JOdEK25Y+65yNpD+FjSSdNzfvY/a8ShZV7gCgc34215w3lC+dM6Rt6ikd6J42kknS51+upLzV22uYM7+KJ96INcMsyM3iqnOGcPW4oRQVBNfuPyxt02g6ZyMZQGEjodu4q457FlTx6KubiTrkZnfgCx8exFfKhtGzU17Y5QXmH73RNI0m6U9hI6F5d98B7l24mj+ueIdINNaJ+XP/NIBrJ4ygd1F+2OUFTkufJZMobCThdtTEOjH/7qUNNEaidDD41Jj+XH/+CAZ0Lwi7vIQpaLnddJ3CRjKAwkYSZm9dI3OfW8uvF6/nQFNs6uhjo/pw46QShp/UKeTqEk+90SSTKGwkcLUNEX75wjp+9txaalo+WCedchI3Ti7hQ32TqxNzIrV1fW5sxt1TosWOyIlS2Ehg6pua+e3S9dxfvoY9dU0AnDu8JzdNKeHMgd3CLS4J5GZ3IDerA43NURoi0bS4dkjkaBQ20u4aI1EeWr6R+55ZzfaaBgDGDOrGrCmlfGRYj5CrSy6FeVk01kXZ3xBR2EhaU9hIu4k0R3nklc3894JVbN4b68Q8sl8Xbp5SSllJsaaJjqAwL5s9dU3sb2imR+adtpIMorCRDywadf7vjXe5Z34Va3fGOjGPOKkTN08p4YIP9VbIHENbyxpd2ClpTmEjJ8zdmf/WNubMr+LtrTUADOpRwI2TSph2el+yUqjdf1jUjFMyhcJGjpu78+bOCHf/eDGvbdoHQN+ifL5+/gimj+lPTgq2+w9LoZY/S4ZQ2MhxWb5+N3c+XcmydQ1AAz075TFzwjD++eyBOsF9Alqn0eoa1bJG0pvCRuLy+qa93DWviueqYp2YC3Pg2vNP5sqPDmq7XkSOn45sJFPoU0KOqXJrDXPmV/L037cBsave/+XcIZSymallw0KuLvV10jkbyRAKGzmidTv3c/f8Kv76+hbcIT+nA1d+ZDDXjB9G98Jcysu3hF1iWijI0zSaZAaFjRxi894D3LtgFX96eRPNUScny/jc2QOZOWE4J3VJ/07Miab+aJIpFDYCwPaaen6yaA1/eGkjjc1RsjoYl40dwHXnD6d/t8zpxJxohbmaRpPMkPRhY2ZnADOBM4nVmwMsAH7g7jvCrC0d7NnfyE+fW8NvlqynvimKGXzi9L7cOLmEIT0Lwy4v7RW03dNG02iS3pI+bIAHgb8D57n7fjPrBywELjSz0939QLjlpabq+iZ+8fw6fvHCurYpnAs+1IsbJ5dwcu8uIVeXOXQDNckUqRA2AN909/0A7r7ZzO4Efg5MBf4camUppq4xwm+WbGDuc2vY29KJeXxJMTdPKWFU/64hV5d5Wpc+q12NpLtUCJtR7t542LbWpVDqUx+nhkgzf3hpIz9etIadtbFOzGcP6c6sKaWcPaR7yNVlLi19lkyR9GFzhKABKAEceO5IzzGzGcAMgOLiYsrLywOrL9lFos4LmyM8vqaJ3fUOwJCiDkwfkcuHetRTt+F1yjcc/+vW1tZm9Li2l3dqogBs372P8vJyjWtANK7hS/qwOZyZZQFXAb9w96oj7ePuDwAPAJSWlnpZWVniCkwSzVHnr69t4e4FVWzYFcvrk3t35qbJJUw+tdcH7sRcXl5OJo5re3tndx0sXoRn51NWVqZxDYjGNXwpFzbAd4EIcGPYhSQjd+fpv29lzvwqqrbVAjC0ZyHXTxrBtFF96aBOzEmlsO2iTk2jSXpLqbAxsy8BnwHK3L027HqSibvzbNUOZs+r4o3NsU7M/bp25PrzR/DJM/uRrU7MSamg7TobLX2W9JYyYWNmVwA3AxPdfXvY9SSTpWt2MXteJSs27AHgpM55XDdxOJ85awB52erEnMzysjuQ3cFobI7SGImGXY5IYFIibMzscuCbwCR339qy7eNA35bzMxnplY17mD2vihdW7wSgW0EOXy0bxhUfHkzHXIVMKjAzCvOy2XegSVNpktaSPmzM7PPAz4idq5l00IntccC7YdUVpre2VDNnfiULVsYO8DrnZXP1eUO56twhbRcJSuoozM1i34Em9UeTtJYKn0z3AfnAnUd47LYE1xKq1dtruXtBFX97PZaxHXOy+NI5g5lx3lC6FuSGXJ2cqEK1rJEMkPRh4+4Zf8XhO7vruGfBKv7yyiaiDrlZHfj8hwfytbLhFHfOC7s8+YDURUAyQdKHTSbbuq+e+55ZxUPL3yESdbI7GJed1Z/rJo6gb9eOYZcn7aRQXQQkAyhsktCu2gbuL1/D/7y4gYZIrBPzJ0f34/pJIxjUQ52Y001h7j+aceqOQZKuFDZJZN+BJn723Fp+uXhd250bp57WmxsnlTCiV+eQq5OgdDronI3CRtKVwiYJ7G+I8Osl65n77Bqq62NTKRNPPombJpcwsl9RyNVJ0Apap9EaI/QIuRaRoChsQlTf1MzvXtzA/eVr2LU/1r/sI0N7MOuCEsYMyvh1ERmjULeGlgygsAlBYyTKHyve4b6Fq9laXQ/A6IFdmTWllHOG9wy5Okm0Ti3nbOoamkGLCyVNKWwSqDnqPPrKZu5ZWMU7u2M3GD21TxdmXVDChNKTPnAnZklNBQcf2ShsJE0pbBIgGnWefHMrc+ZXsmbHfgCGFRdy0+RSLhrZW52YM5xuoCaZQGETIHfnmbe3M3teFW+9Ww3AgO4dueH8Ei4Z3Y8shYxw8G0G1EFA0pfCJiBLVu/krnmVvLxxLwC9u+Rz3fnD+fSYAeRmq92//EPrdTZaICDpTGHTzio27OGupytZunYXAD0Kc/nahOF8/p8Gkp+jTszyXv/ojaawkfSlsGknb27ex+x5lSyq3AFAl/xsrhk/jC9+dHDbh4nIkbS1q9E0mqQxfQp+QKu21TBnfhVPvrkViLWLv+rcIXx53FCKOuaEXJ2kgoPb1YDO40l6UticoA279nPPglU8+upm3GN3XPzCRwbxlfHD6NFJ61clfodOo+k/KJKeFDbHacveA9z3zCoeXrGJ5qiTk2VcdtYArps4gl5d1NlKjl+nQ24xoLCR9KSwidOOmgZ+Ur6a37+4kcbmKB0MPjWmP9efP4IB3QvCLk9SWH5OBzoY1DdFaY562OWIBEJh8z721jUy97m1/Hrxeg40xU7gfmxUH26cVMLwkzqFXJ2kAzOjMDebmoYI9VojIGlKYXMUtQ0RfvnCOn723FpqWpakTjqlFzdNLuHUvl1Crk7STWFeLGwamnVkI+lJYXOYA43N/M+L67m/fA176poAOHd4T26eUsLogd1Crk7SVettBup1qY2kKYVNi4ZIMw8tf4cfPbOa7TUNAIwd1I1ZF5Ty4aG6y4gEq3WRQH1ERzaSnjI+bCLNUR55eTP/vXAVm/fGOjGf1q+Im6eUML6kWJ2YJSFar7XRORtJVxkbNtGo89fXt3DPglWs2xnrxFzSqxM3TS7lgg/1UshIQhW2TaPpyEbSU9KHjZmdBNwNjG3Z9AZwg7tvOpHXc3fmvbWNOfOqqNxWA8CgHgXcOKmEaaf3VSdmCUXrhZ06spF0ldRhY2a5wHygCvgQ4MAvgUVmNtrda+N9LXfn+VU7mT2vktc27QOgb1E+Xz9/BNPH9CcnS52YJTyFOmcjaS6pwwa4EhgFXOruEQAz+yawGfgqcGc8L7Js3W7uerqSZet3A9CzUx4zJwzjc/80kLxsdWKW8BXmtkyjaemzpKlkD5vpwEZ3X9u6wd23mtlbLY+9b9hsq3M+M3cpAEUdc/jK+GFc+dFBFOQm+48umaT1yGZvvfPuvgMhV5N+dtdHNa4hS/ZP3FHEptAOtw44P54XOBBx+udl8y/nDuFfxg2hS756T0nyaV36PG9DhHn/+UzI1aSpco1rmJI9bHoCFUfYXg0UmFlHd3/Pf1fMbAYwA6DzSQO445xcOuVs4eUXtwRbbQapra2lvLw87DLSRkFtlP6djNrGKGY6f9je3DWuQdhwHPuae/LOEZtZI/C0u087bPvvgc8BBUcKm4OVlpZ6ZWVlgFVmpvLycsrKysIuI+1oXIOhcQ3k8UC0AAAFwklEQVSGmVW4+9j33xOSPep3Ap2PsL0zUPd+QSMiIskh2cPmdWDwEbYPIXa9jYiIpIBkD5tHgEFmNrh1g5n1Ak4B/hxSTSIicpySPWx+TewI5r/MLNtiZ/juILYa7f4wCxMRkfglddi4eyMwGWgG3gJWAl2AicfTPUBERMKV7EufcfdtxFaeiYhIikrqIxsREUkPSX2dTXswsxpAF9q0v57ElqZL+9K4BkPjGoxSdz/S5SnvkfTTaO2gMt6LjiR+ZrZC49r+NK7B0LgGw8xWxLuvptFERCRwChsREQlcJoTNA2EXkKY0rsHQuAZD4xqMuMc17RcIiIhI+DLhyEZEREKmsBERkcApbCRuZtbHzJ4yM829ighm9ryZ+cHNko8mLcPGzE4ys9+bWWXL15/MrH/YdaUyM7sUWAoMC7uWdGJmZ5jZz8yswsxeM7O3zOxeMysOu7ZUZmbDzOyulnGtMLOqlg/Gj4VdW7ows+nAufHun3ZhY2a5wHwgF/gQcCqwH1hkZp3CrC3FfYtYU9TFYReSZh4EugPnufvpxMZ4CrDYzDqGWllquwj4LHCZu48BTib2n6XHzWx8qJWlgZbP2f8Enoj3OWkXNsCVwCjgm+4ecfdm4JvAUOCroVaW2s5x91VhF5Gmvunu+wHcfTNwJzACmBpqValtM/A9d18N4O5R4D+IfeZdHGZhaWImsAJYHu8T0jFspgMb3X1t6wZ330rsFgXTQ6sqxbl7JOwa0tSo1g/Eg2xp+d4t0cWkC3f/i7v//LDNXVq+70h0PenEzLoD3wD+7Xiel45hM4rYzdUOtw44LcG1iBxTyz2bDlcCOPBcgstJW2bWD/gx8HLLdzlxtwC/c/f1x/OkdAybnkDNEbZXAwWaB5dkZmZZwFXAL9y9Kux6Ul3LQoHVwCYgC7jE3atDLitlmdlw4DPA7cf73HQMm6OxsAsQicN3gQhwY9iFpAN3X+Puw4EioAp4zcziXkEl7/FD4A5333e8T0zHsNkJHOn+Cp2BOnc/kOB6ROJiZl8i9r/Gi3Tb8/bVcjRzI7AN+EnI5aQkMxsHjATuP5Hnp+P9bF4ntszxcEOANxJci0hczOwK4GZgortvD7ueVNcyXV7vBzV/dHc3szeAT5lZnrs3hFdhSppMbCpyuVnbRFHvlu9PmFkj8G/ufsTl0Ol4ZPMIMOjgK1rNrBdwCvDnkGoSOSozu5zY8vxJLSsnMbOPm9mMcCtLaU8CHz7C9sHEzt8eaWGGHIO73+Luw9z9jNYv4KctD09t2XbU627SMWx+TewI5r/MLNvMOgB3EFuNdkKHfyJBMbPPAz8j9vd2kpld3hI+04C+YdaWBm4zsx4AFnMdcBZw78FHPJIYaXmLgZYjmbuBscSWkL4J3ODu74RaWAozszuJHUYPJHb9x2stD519lOW7Egcz283Rr6e5zd2/l8By0oaZnQN8mVi4RIB8YBex8zV/UNh8MGY2ldhFsr2BXsBKoLHlaOfIz9GYi4hI0NJxGk1ERJKMwkZERAKnsBERkcApbEREJHAKGxERCZzCRkREAqewERGRwClsREQkcAobEREJnMJGREQCp7AREZHAKWxEQmRmw82sycxuO2z7/WZWY2Zjw6pNpD0pbERC5O6rgZ8DN5pZTwAzuwW4CrjU3VeEWZ9Ie1HXZ5GQmVlvYA2x9vdvAw8A/+zuD4damEg7SsfbQoukFHffamb3ELstdDbwdQWNpBtNo4kkh1VAHrDU3X8cdjEi7U1hIxIyM5sIzAWWAueY2ekhlyTS7hQ2IiEyszOBR4ktEigDNhK73a5IWlHYiITEzIYDTwLzgOvcvRG4DZhqZueFWpxIO9NqNJEQtKxAW0LsSOYCd29o2Z4FvAnscfePhliiSLtS2IiISOA0jSYiIoFT2IiISOAUNiIiEjiFjYiIBE5hIyIigVPYiIhI4BQ2IiISOIWNiIgETmEjIiKB+//xqfISEN0Q+AAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Modify some parameters.\n", + "nt = 40 # number of time step to compute\n", + "rho_light = 5.0 # car density at the stoplight\n", + "\n", + "# Compute the initial traffic density.\n", + "rho0 = rho_green_light(x, rho_light)\n", + "\n", + "# Plot the initial traffic density.\n", + "fig = pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel(r'$x$')\n", + "pyplot.ylabel(r'$\\rho$')\n", + "pyplot.grid()\n", + "line = pyplot.plot(x, rho0,\n", + " color='C0', linestyle='-', linewidth=2)[0]\n", + "pyplot.hlines(rho_max / 2.0, 0.0, L,\n", + " label=r'$\\rho_{max} / 2$',\n", + " color='black', linestyle='--', linewidth=2)\n", + "pyplot.legend()\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(-0.5, 11.0)\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute the traffic density at all time steps.\n", + "rho_hist = ftbs(rho0, nt, dt, dx, rho0[0], u_max, rho_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create an animation of the traffic density.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(rho_hist,),\n", + " interval=100)\n", + "# Display the animation.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Phew! It works! Try this out yourself with different initial conditions. \n", + "\n", + "Also, you can easily create a new function `ftfs` to do a forward-time/forward-space scheme, which is stable for negative wave speeds. Unfortunately, forward in space is unstable for positive wave speeds. If you don't want it blowing up, make sure the wave speed is negative everywhere: $u_{\\rm wave} = \\frac{\\partial F}{\\partial \\rho} < 0 \\ \\forall \\ x$.\n", + "\n", + "Look at that solution again, and you'll get some nice insights of the real physical problem. See how on the trailing edge, a shock is developing? In the context of the traffic flow problem, a shock is a sign of a traffic jam: a region where traffic is heavy and slow next to a region that is free of cars. In the initial condition, the cars in the rear end of the triangle see a mostly empty road (traffic density is low!). They see an empty road and speed up, accordingly. The cars in the peak of the triangle are moving pretty slowly because traffic density is higher there. Eventually the cars that started in the rear will catch up with the rest and form a traffic jam." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Beware the CFL!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Lesson 2 of Module 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_02_CFLCondition.ipynb) discusses the CFL condition for the linear convection equation. To refresh your memory, for a constant wave speed $u_{\\rm wave} = c$:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\sigma = c\\frac{\\Delta t}{\\Delta x} < 1\n", + "\\end{equation}\n", + "$$\n", + "\n", + "What happens for non-linear equations? The wave speed is space- and time-dependent, $u_{\\rm wave} = u_{\\rm wave}(x,t)$, and the CFL condition needs to apply for every point in space, at every instant of time. We just need $\\sigma>1$ in one spot, for the whole solution to blow up! \n", + "\n", + "Let's generalize the CFL condition to\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\sigma = \\max\\left[ \\left| u_{\\rm wave} \\right| \\frac{\\Delta t}{\\Delta x} \\right] < 1\n", + "\\end{equation}\n", + "$$\n", + "\n", + "which in our case is\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\sigma = \\max\\left[ u_{\\rm max} \\left| 1-\\frac{2 \\rho}{\\rho_{\\rm max}} \\right| \\frac{\\Delta t}{\\Delta x} \\right] < 1\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Here, the closer $\\rho$ is to zero, the more likely it is to be unstable." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Green light and CFL" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We know that the green-light problem with density at the stop light $\\rho = \\rho_{\\rm light} = 4$ is stable using a forward-time/backward -space scheme. Earlier, we used $u_{\\rm max} = 1$, and $\\Delta t/\\Delta x=1$, which gives a CFL $= 1$, when $\\rho = 0$. \n", + "\n", + "What if we change the conditions slightly, say $u_{\\rm max} = 1.1$? " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Set parameters.\n", + "rho_light = 4.0\n", + "u_max = 1.1\n", + "\n", + "# Compute the initial traffic density.\n", + "rho0 = rho_green_light(x, rho_light)\n", + "\n", + "# Compute the traffic density at all time steps.\n", + "rho_hist = ftbs(rho0, nt, dt, dx, rho0[0], u_max, rho_max)\n", + "\n", + "# Create an animation of the traffic density.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(rho_hist,),\n", + " interval=100)\n", + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That failed miserably! Only by changing $u_{\\rm max}$ to $1.1$, even an algorithm that we know is stable for this problem, fails. Since we kept $\\Delta t/\\Delta x=1$, the CFL number for $\\rho=0$ is $1.1$. See where the instability begins? Beware the CFL!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Neville D. Fowkes and John J. Mahony, *\"An Introduction to Mathematical Modelling,\"* Wiley & Sons, 1994. Chapter 14: Traffic Flow.\n", + "\n", + "* M. J. Lighthill and G. B. Whitham (1955), On kinematic waves. II. Theory of traffic flow and long crowded roads, _Proc. Roy. Soc. A_, Vol. 229, pp. 317–345. [PDF from amath.colorado.edu](https://amath.colorado.edu/sites/default/files/2013/09/1710796241/PRSA_Lighthill_1955.pdf), checked Oct. 14, 2014. [Original source](http://rspa.royalsocietypublishing.org/content/229/1178/317.short) on the Royal Society site." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/03_wave/03_02_convectionSchemes.ipynb b/2-finite-difference-method/lessons/03_wave/03_02_convectionSchemes.ipynb new file mode 100644 index 0000000..5c5e744 --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/03_02_convectionSchemes.ipynb @@ -0,0 +1,3329 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, C.D. Cooper, G.F. Forsyth." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Riding the wave" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Numerical schemes for hyperbolic PDEs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome back! This is the second notebook of *Riding the wave: Convection problems*, the third module of [\"Practical Numerical Methods with Python\"](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about). \n", + "\n", + "The first notebook of this module discussed conservation laws and developed the non-linear traffic equation. We learned about the effect of the wave speed on the stability of the numerical method, and on the CFL number. We also realized that the forward-time/backward-space difference scheme really has many limitations: it cannot deal with wave speeds that move in more than one direction. It is also first-order accurate in space and time, which often is just not good enough. This notebook will introduce some new numerical schemes for conservation laws, continuing with the traffic-flow problem as motivation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Red light!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's explore the behavior of different numerical schemes for a moving shock wave. In the context of the traffic-flow model of the previous notebook, imagine a very busy road and a red light at $x=4$. Cars accumulate quickly in the front, where we have the maximum allowed density of cars between $x=3$ and $x=4$, and there is an incoming traffic of 50% the maximum allowed density $(\\rho = 0.5\\rho_{\\rm max})$. \n", + "\n", + "Mathematically, this is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\rho(x,0) = \\left\\{\n", + "\\begin{array}{cc}\n", + "0.5 \\rho_{\\rm max} & 0 \\leq x < 3 \\\\\n", + "\\rho_{\\rm max} & 3 \\leq x \\leq 4 \\\\\n", + "\\end{array}\n", + "\\right.\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Let's find out what the initial condition looks like." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def rho_red_light(x, rho_max):\n", + " \"\"\"\n", + " Computes the \"red light\" initial condition with shock.\n", + " \n", + " Parameters\n", + " ----------\n", + " x : numpy.ndaray\n", + " Locations on the road as a 1D array of floats.\n", + " rho_max : float\n", + " The maximum traffic density allowed.\n", + " \n", + " Returns\n", + " -------\n", + " rho : numpy.ndarray\n", + " The initial car density along the road\n", + " as a 1D array of floats.\n", + " \"\"\"\n", + " rho = rho_max * numpy.ones_like(x)\n", + " mask = numpy.where(x < 3.0)\n", + " rho[mask] = 0.5 * rho_max\n", + " return rho" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "nx = 81 # number of locations on the road\n", + "L = 4.0 # length of the road\n", + "dx = L / (nx - 1) # distance between two consecutive locations\n", + "nt = 40 # number of time steps to compute\n", + "rho_max = 10.0 # maximum taffic density allowed\n", + "u_max = 1.0 # maximum speed traffic\n", + "\n", + "# Get the road locations.\n", + "x = numpy.linspace(0.0, L, num=nx)\n", + "\n", + "# Compute the initial traffic density.\n", + "rho0 = rho_red_light(x, rho_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the initial traffic density.\n", + "fig = pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel(r'$x$')\n", + "pyplot.ylabel(r'$\\rho$')\n", + "pyplot.grid()\n", + "line = pyplot.plot(x, rho0,\n", + " color='C0', linestyle='-', linewidth=2)[0]\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(4.0, 11.0)\n", + "pyplot.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The question we would like to answer is: **How will cars accumulate at the red light?** \n", + "\n", + "We will solve this problem using different numerical schemes, to see how they perform. These schemes are:\n", + "\n", + " * Lax-Friedrichs\n", + " * Lax-Wendroff\n", + " * MacCormack" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before we do any coding, let's think about the equation a little bit. The wave speed $u_{\\rm wave}$ is $-1$ for $\\rho = \\rho_{\\rm max}$ and $\\rho \\leq \\rho_{\\rm max}/2$, making all velocities negative. We should see a solution moving left, maintaining the shock geometry.\n", + "\n", + "![squarewave](./figures/squarewave.png)\n", + "#### Figure 1. The exact solution is a shock wave moving left.\n", + "\n", + "Now to some coding! First, let's define some useful functions and prepare to make some nice animations later." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def flux(rho, u_max, rho_max):\n", + " \"\"\"\n", + " Computes the traffic flux F = V * rho.\n", + " \n", + " Parameters\n", + " ----------\n", + " rho : numpy.ndarray\n", + " Traffic density along the road as a 1D array of floats.\n", + " u_max : float\n", + " Maximum speed allowed on the road.\n", + " rho_max : float\n", + " Maximum car density allowed on the road.\n", + " \n", + " Returns\n", + " -------\n", + " F : numpy.ndarray\n", + " The traffic flux along the road as a 1D array of floats.\n", + " \"\"\"\n", + " F = rho * u_max * (1.0 - rho / rho_max)\n", + " return F" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before we investigate different schemes, let's create the function to update the Matplotlib figure during the animation." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import animation\n", + "from IPython.display import HTML" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def update_plot(n, rho_hist):\n", + " \"\"\"\n", + " Update the line y-data of the Matplotlib figure.\n", + " \n", + " Parameters\n", + " ----------\n", + " n : integer\n", + " The time-step index.\n", + " rho_hist : list of numpy.ndarray objects\n", + " The history of the numerical solution.\n", + " \"\"\"\n", + " fig.suptitle('Time step {:0>2}'.format(n))\n", + " line.set_ydata(rho_hist[n])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lax-Friedrichs scheme" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recall the conservation law for vehicle traffic, resulting in the following equation for the traffic density:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial \\rho}{\\partial t} + \\frac{\\partial F}{\\partial x} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "$F$ is the *traffic flux*, which in the linear traffic-speed model is given by: \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "F = \\rho u_{\\rm max} \\left(1-\\frac{\\rho}{\\rho_{\\rm max}}\\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "In the time variable, the natural choice for discretization is always a forward-difference formula; time invariably moves forward!\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial \\rho}{\\partial t}\\approx \\frac{1}{\\Delta t}( \\rho_i^{n+1}-\\rho_i^n )\n", + "\\end{equation}\n", + "$$\n", + "\n", + "As is usual, the discrete locations on the 1D spatial grid are denoted by indices $i$ and the discrete time instants are denoted by indices $n$.\n", + "\n", + "In a convection problem, using first-order discretization in space leads to excessive numerical diffusion (as you probably observed in [Lesson 1 of Module 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_01_1DConvection.ipynb)). The simplest approach to get second-order accuracy in space is to use a central difference:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial F}{\\partial x} \\approx \\frac{1}{2\\Delta x}( F_{i+1}-F_{i-1})\n", + "\\end{equation}\n", + "$$\n", + "\n", + "But combining these two choices for time and space discretization in the convection equation has catastrophic results! The \"forward-time, central scheme\" (FTCS) is **unstable**. (Go on: try it; you know you want to!)\n", + "\n", + "The Lax-Friedrichs scheme was proposed by Lax (1954) as a clever trick to stabilize the forward-time, central scheme. The idea was to replace the solution value at $\\rho^n_i$ by the average of the values at the neighboring grid points. If we do that replacement, we get the following discretized equation: \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\rho_i^{n+1}-\\frac{1}{2}(\\rho^n_{i+1}+\\rho^n_{i-1})}{\\Delta t} = -\\frac{F^n_{i+1}-F^n_{i-1}}{2 \\Delta x}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Take a careful look: the difference formula no longer uses the value at $\\rho^n_i$ to obtain $\\rho^{n+1}_i$. The stencil of the Lax-Friedrichs scheme is slightly different than that for the forward-time, central scheme." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Stencil of the forward-time central scheme](./figures/FD-stencil_FTCS.png)\n", + "#### Figure 2. Stencil of the forward-time/central scheme.\n", + "\n", + "![Stencil of the Lax-Friedrichs scheme](./figures/FD-stencil_LF.png)\n", + "#### Figure 3. Stencil of the Lax-Friedrichs scheme." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This numerical discretization is **stable**. Unfortunately, substituting $\\rho^n_i$ by the average of its neighbors introduces a first-order error. _Nice try, Lax!_\n", + "\n", + "To implement the scheme in code, we need to isolate the value at the next time step, $\\rho^{n+1}_i$, so we can write a time-stepping loop:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\rho_i^{n+1} = \\frac{1}{2}(\\rho^n_{i+1}+\\rho^n_{i-1}) - \\frac{\\Delta t}{2 \\Delta x}(F^n_{i+1}-F^n_{i-1})\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The function below implements Lax-Friedrichs for our traffic model. All the schemes in this notebook are wrapped in their own functions to help with displaying animations of the results. This is also good practice for developing modular, reusable code.\n", + "\n", + "In order to display animations, we're going to hold the results of each time step in the variable `rho`, a 2D array. The resulting array `rho_n` has `nt` rows and `nx` columns." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def lax_friedrichs(rho0, nt, dt, dx, bc_values, *args):\n", + " \"\"\"\n", + " Computes the traffic density on the road \n", + " at a certain time given the initial traffic density.\n", + " Integration using Lax-Friedrichs scheme.\n", + " \n", + " Parameters\n", + " ----------\n", + " rho0 : numpy.ndarray\n", + " The initial traffic density along the road\n", + " as a 1D array of floats.\n", + " nt : integer\n", + " The number of time steps to compute.\n", + " dt : float\n", + " The time-step size to integrate.\n", + " dx : float\n", + " The distance between two consecutive locations.\n", + " bc_values : 2-tuple of floats\n", + " The value of the density at the first and last locations.\n", + " args : list or tuple\n", + " Positional arguments to be passed to the flux function.\n", + " \n", + " Returns\n", + " -------\n", + " rho_hist : list of numpy.ndarray objects\n", + " The history of the car density along the road.\n", + " \"\"\"\n", + " rho_hist = [rho0.copy()]\n", + " rho = rho0.copy()\n", + " for n in range(nt):\n", + " # Compute the flux.\n", + " F = flux(rho, *args)\n", + " # Advance in time using Lax-Friedrichs scheme.\n", + " rho[1:-1] = (0.5 * (rho[:-2] + rho[2:]) -\n", + " dt / (2.0 * dx) * (F[2:] - F[:-2]))\n", + " # Set the value at the first location.\n", + " rho[0] = bc_values[0]\n", + " # Set the value at the last location.\n", + " rho[-1] = bc_values[1]\n", + " # Record the time-step solution.\n", + " rho_hist.append(rho.copy())\n", + " return rho_hist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lax-Friedrichs with $\\frac{\\Delta t}{\\Delta x}=1$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are now all set to run! First, let's try with CFL=1" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the time-step size based on CFL limit.\n", + "sigma = 1.0\n", + "dt = sigma * dx / u_max # time-step size\n", + "\n", + "# Compute the traffic density at all time steps.\n", + "rho_hist = lax_friedrichs(rho0, nt, dt, dx, (rho0[0], rho0[-1]),\n", + " u_max, rho_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create an animation of the traffic density.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(rho_hist,),\n", + " interval=100)\n", + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Think" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* What do you see in the animation above? How does the numerical solution compare with the exact solution (a left-traveling shock wave)? \n", + "* What types of errors do you think we see? \n", + "* What do you think of the Lax-Friedrichs scheme, so far?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lax-Friedrichs with $\\frac{\\Delta t}{\\Delta x} = 0.5$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Would the solution improve if we use smaller time steps? Let's check that!" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the time-step size based on CFL limit.\n", + "sigma = 0.5\n", + "dt = sigma * dx / u_max # time-step size\n", + "\n", + "# Compute the traffic density at all time steps.\n", + "rho_hist = lax_friedrichs(rho0, nt, dt, dx, (rho0[0], rho0[-1]),\n", + " u_max, rho_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create an animation of the traffic density.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(rho_hist,),\n", + " interval=100)\n", + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Dig deeper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice the strange \"staircase\" behavior on the leading edge of the wave? You may be interested to learn more about this: a feature typical of what is sometimes called \"odd-even decoupling.\" Last year we published a collection of lessons in Computational Fluid Dynamics, called _CFD Python_, where we discuss [odd-even decoupling](https://nbviewer.jupyter.org/github/barbagroup/CFDPython/blob/14b56718ac1508671de66bab3fe432e93cb59fcb/lessons/19_Odd_Even_Decoupling.ipynb).\n", + "\n", + "* How does this solution compare with the previous one, where the Courant number was $\\frac{\\Delta t}{\\Delta x}=1$?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lax-Wendroff scheme" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Lax-Friedrichs method uses a clever trick to stabilize the central difference in space for convection, but loses an order of accuracy in doing so. First-order methods are just not good enough for convection problems, especially when you have sharp gradients (shocks).\n", + "\n", + "The Lax-Wendroff (1960) method was the _first_ scheme ever to achieve second-order accuracy in both space and time. It is therefore a landmark in the history of computational fluid dynamics.\n", + "\n", + "To develop the Lax-Wendroff scheme, we need to do a bit of work. Sit down, grab a notebook and grit your teeth. We want you to follow this derivation in your own hand. It's good for you! Start with the Taylor series expansion (in the time variable) about $\\rho^{n+1}$:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\rho^{n+1} = \\rho^n + \\frac{\\partial\\rho^n}{\\partial t} \\Delta t + \\frac{(\\Delta t)^2}{2}\\frac{\\partial^2\\rho^n}{\\partial t^2} + \\ldots\n", + "\\end{equation}\n", + "$$\n", + "\n", + "For the conservation law with $F=F(\\rho)$, and using our beloved chain rule, we can write:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial \\rho}{\\partial t} = -\\frac{\\partial F}{\\partial x} = -\\frac{\\partial F}{\\partial \\rho} \\frac{\\partial \\rho}{\\partial x} = -J \\frac{\\partial \\rho}{\\partial x}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "J = \\frac{\\partial F}{\\partial \\rho} = u _{\\rm max} \\left(1-2\\frac{\\rho}{\\rho_{\\rm max}} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "is the _Jacobian_ for the traffic model. Next, we can do a little trickery:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial F}{\\partial t} = \\frac{\\partial F}{\\partial \\rho} \\frac{\\partial \\rho}{\\partial t} = J \\frac{\\partial \\rho}{\\partial t} = -J \\frac{\\partial F}{\\partial x}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "In the last step above, we used the differential equation of the traffic model to replace the time derivative by a spatial derivative. These equivalences imply that\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial^2\\rho}{\\partial t^2} = \\frac{\\partial}{\\partial x} \\left( J \\frac{\\partial F}{\\partial x} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Let's use all this in the Taylor expansion:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\rho^{n+1} = \\rho^n - \\frac{\\partial F^n}{\\partial x} \\Delta t + \\frac{(\\Delta t)^2}{2} \\frac{\\partial}{\\partial x} \\left(J\\frac{\\partial F^n}{\\partial x} \\right)+ \\ldots\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We can now reorganize this and discretize the spatial derivatives with central differences to get the following discrete equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\rho_i^{n+1} - \\rho_i^n}{\\Delta t} = -\\frac{F^n_{i+1}-F^n_{i-1}}{2 \\Delta x} + \\frac{\\Delta t}{2} \\left(\\frac{(J \\frac{\\partial F}{\\partial x})^n_{i+\\frac{1}{2}}-(J \\frac{\\partial F}{\\partial x})^n_{i-\\frac{1}{2}}}{\\Delta x}\\right)\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, approximate the rightmost term (inside the parenthesis) in the above equation as follows:\n", + "\\begin{equation} \\frac{J^n_{i+\\frac{1}{2}}\\left(\\frac{F^n_{i+1}-F^n_{i}}{\\Delta x}\\right)-J^n_{i-\\frac{1}{2}}\\left(\\frac{F^n_i-F^n_{i-1}}{\\Delta x}\\right)}{\\Delta x}\\end{equation}\n", + "\n", + "Then evaluate the Jacobian at the midpoints by using averages of the points on either side:\n", + "\n", + "\\begin{equation}\\frac{\\frac{1}{2 \\Delta x}(J^n_{i+1}+J^n_i)(F^n_{i+1}-F^n_i)-\\frac{1}{2 \\Delta x}(J^n_i+J^n_{i-1})(F^n_i-F^n_{i-1})}{\\Delta x}.\\end{equation}\n", + "\n", + "Our equation now reads:\n", + "\n", + "\\begin{align}\n", + "&\\frac{\\rho_i^{n+1} - \\rho_i^n}{\\Delta t} = \n", + "-\\frac{F^n_{i+1}-F^n_{i-1}}{2 \\Delta x} + \\cdots \\\\ \\nonumber \n", + "&+ \\frac{\\Delta t}{4 \\Delta x^2} \\left( (J^n_{i+1}+J^n_i)(F^n_{i+1}-F^n_i)-(J^n_i+J^n_{i-1})(F^n_i-F^n_{i-1})\\right)\n", + "\\end{align}\n", + "\n", + "Solving for $\\rho_i^{n+1}$:\n", + "\n", + "\\begin{align}\n", + "&\\rho_i^{n+1} = \\rho_i^n - \\frac{\\Delta t}{2 \\Delta x} \\left(F^n_{i+1}-F^n_{i-1}\\right) + \\cdots \\\\ \\nonumber \n", + "&+ \\frac{(\\Delta t)^2}{4(\\Delta x)^2} \\left[ (J^n_{i+1}+J^n_i)(F^n_{i+1}-F^n_i)-(J^n_i+J^n_{i-1})(F^n_i-F^n_{i-1})\\right]\n", + "\\end{align}\n", + "\n", + "with\n", + "\n", + "\\begin{equation}J^n_i = \\frac{\\partial F}{\\partial \\rho} = u_{\\rm max} \\left(1-2\\frac{\\rho^n_i}{\\rho_{\\rm max}} \\right).\\end{equation} \n", + "\n", + "Lax-Wendroff is a little bit long. Remember that you can use \\ slashes to split up a statement across several lines. This can help make code easier to parse (and also easier to debug!). " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def jacobian(rho, u_max, rho_max):\n", + " \"\"\"\n", + " Computes the Jacobian for our traffic model.\n", + " \n", + " Parameters\n", + " ----------\n", + " rho : numpy.ndarray\n", + " Traffic density along the road as a 1D array of floats.\n", + " u_max : float\n", + " Maximum speed allowed on the road.\n", + " rho_max : float\n", + " Maximum car density allowed on the road.\n", + " \n", + " Returns\n", + " -------\n", + " J : numpy.ndarray\n", + " The Jacobian as a 1D array of floats.\n", + " \"\"\"\n", + " J = u_max * (1.0 - 2.0 * rho / rho_max)\n", + " return J" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def lax_wendroff(rho0, nt, dt, dx, bc_values, *args):\n", + " \"\"\"\n", + " Computes the traffic density on the road \n", + " at a certain time given the initial traffic density.\n", + " Integration using Lax-Wendroff scheme.\n", + " \n", + " Parameters\n", + " ----------\n", + " rho0 : numpy.ndarray\n", + " The initial traffic density along the road\n", + " as a 1D array of floats.\n", + " nt : integer\n", + " The number of time steps to compute.\n", + " dt : float\n", + " The time-step size to integrate.\n", + " dx : float\n", + " The distance between two consecutive locations.\n", + " bc_values : 2-tuple of floats\n", + " The value of the density at the first and last locations.\n", + " args : list or tuple\n", + " Positional arguments to be passed to the\n", + " flux and Jacobien functions.\n", + " \n", + " Returns\n", + " -------\n", + " rho_hist : list of numpy.ndarray objects\n", + " The history of the car density along the road.\n", + " \"\"\"\n", + " rho_hist = [rho0.copy()]\n", + " rho = rho0.copy()\n", + " for n in range(nt):\n", + " # Compute the flux.\n", + " F = flux(rho, *args)\n", + " # Compute the Jacobian.\n", + " J = jacobian(rho, *args)\n", + " # Advance in time using Lax-Wendroff scheme.\n", + " rho[1:-1] = (rho[1:-1] -\n", + " dt / (2.0 * dx) * (F[2:] - F[:-2]) +\n", + " dt**2 / (4.0 * dx**2) *\n", + " ((J[1:-1] + J[2:]) * (F[2:] - F[1:-1]) -\n", + " (J[:-2] + J[1:-1]) * (F[1:-1] - F[:-2])))\n", + " # Set the value at the first location.\n", + " rho[0] = bc_values[0]\n", + " # Set the value at the last location.\n", + " rho[-1] = bc_values[1]\n", + " # Record the time-step solution.\n", + " rho_hist.append(rho.copy())\n", + " return rho_hist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that's we've defined a function for the Lax-Wendroff scheme, we can use the same procedure as above to animate and view our results. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lax-Wendroff with $\\frac{\\Delta t}{\\Delta x}=1$" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the time-step size based on CFL limit.\n", + "sigma = 1.0\n", + "dt = sigma * dx / u_max # time-step size\n", + "\n", + "# Compute the traffic density at all time steps.\n", + "rho_hist = lax_wendroff(rho0, nt, dt, dx, (rho0[0], rho0[-1]),\n", + " u_max, rho_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create an animation of the traffic density.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(rho_hist,),\n", + " interval=100)\n", + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Interesting! The Lax-Wendroff method captures the sharpness of the shock much better than the Lax-Friedrichs scheme, but there is a new problem: a strange wiggle appears right at the tail of the shock. This is typical of many second-order methods: they introduce _numerical oscillations_ where the solution is not smooth. Bummer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lax-Wendroff with $\\frac{\\Delta t}{\\Delta x} =0.5$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "How do the oscillations at the shock front vary with changes to the CFL condition? You might think that the solution will improve if you make the time step smaller ... let's see." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the time-step size based on CFL limit.\n", + "sigma = 0.5\n", + "dt = sigma * dx / u_max # time-step size\n", + "\n", + "# Compute the traffic density at all time steps.\n", + "rho_hist = lax_wendroff(rho0, nt, dt, dx, (rho0[0], rho0[-1]),\n", + " u_max, rho_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create an animation of the traffic density.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(rho_hist,),\n", + " interval=100)\n", + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Eek! The numerical oscillations got worse. Double bummer!\n", + "\n", + "Why do we observe oscillations with second-order methods? This is a question of fundamental importance!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## MacCormack Scheme" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The numerical oscillations that you observed with the Lax-Wendroff method on the traffic model can become severe in some problems. But actually the main drawback of the Lax-Wendroff method is having to calculate the Jacobian in every time step. With more complicated equations (like the Euler equations), calculating the Jacobian is a large computational expense.\n", + "\n", + "Robert W. MacCormack introduced the first version of his now-famous method at the 1969 AIAA Hypervelocity Impact Conference, held in Cincinnati, Ohio, but the paper did not at first catch the attention of the aeronautics community. The next year, however, he presented at the 2nd International Conference on Numerical Methods in Fluid Dynamics at Berkeley. His paper there (MacCormack, 1971) was a landslide. MacCormack got a promotion and continued to work on applications of his method to the compressible Navier-Stokes equations. In 1973, NASA gave him the prestigious H. Julian Allen award for his work.\n", + "\n", + "The MacCormack scheme is a two-step method, in which the first step is called a _predictor_ and the second step is called a _corrector_. It achieves second-order accuracy in both space and time. One version is as follows: \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\rho^*_i = \\rho^n_i - \\frac{\\Delta t}{\\Delta x} (F^n_{i+1}-F^n_{i}) \\ \\ \\ \\ \\ \\ \\text{(predictor)}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\rho^{n+1}_i = \\frac{1}{2} (\\rho^n_i + \\rho^*_i - \\frac{\\Delta t}{\\Delta x} (F^*_i - F^{*}_{i-1})) \\ \\ \\ \\ \\ \\ \\text{(corrector)}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "If you look closely, it appears like the first step is a forward-time/forward-space scheme, and the second step is like a forward-time/backward-space scheme (these can also be reversed), averaged with the first result. What is so cool about this? You can compute problems with left-running waves and right-running waves, and the MacCormack scheme gives you a stable method (subject to the CFL condition). Nice! Let's try it." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def maccormack(rho0, nt, dt, dx, bc_values, *args):\n", + " \"\"\"\n", + " Computes the traffic density on the road \n", + " at a certain time given the initial traffic density.\n", + " Integration using MacCormack scheme.\n", + " \n", + " Parameters\n", + " ----------\n", + " rho0 : numpy.ndarray\n", + " The initial traffic density along the road\n", + " as a 1D array of floats.\n", + " nt : integer\n", + " The number of time steps to compute.\n", + " dt : float\n", + " The time-step size to integrate.\n", + " dx : float\n", + " The distance between two consecutive locations.\n", + " bc_values : 2-tuple of floats\n", + " The value of the density at the first and last locations.\n", + " args : list or tuple\n", + " Positional arguments to be passed to the flux function.\n", + " \n", + " Returns\n", + " -------\n", + " rho_hist : list of numpy.ndarray objects\n", + " The history of the car density along the road.\n", + " \"\"\"\n", + " rho_hist = [rho0.copy()]\n", + " rho = rho0.copy()\n", + " rho_star = rho.copy()\n", + " for n in range(nt):\n", + " # Compute the flux.\n", + " F = flux(rho, *args)\n", + " # Predictor step of the MacCormack scheme.\n", + " rho_star[1:-1] = (rho[1:-1] -\n", + " dt / dx * (F[2:] - F[1:-1]))\n", + " # Compute the flux.\n", + " F = flux(rho_star, *args)\n", + " # Corrector step of the MacCormack scheme.\n", + " rho[1:-1] = 0.5 * (rho[1:-1] + rho_star[1:-1] -\n", + " dt / dx * (F[1:-1] - F[:-2]))\n", + " # Set the value at the first location.\n", + " rho[0] = bc_values[0]\n", + " # Set the value at the last location.\n", + " rho[-1] = bc_values[1]\n", + " # Record the time-step solution.\n", + " rho_hist.append(rho.copy())\n", + " return rho_hist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MacCormack with $\\frac{\\Delta t}{\\Delta x} = 1$" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the time-step size based on CFL limit.\n", + "sigma = 1.0\n", + "dt = sigma * dx / u_max # time-step size\n", + "\n", + "# Compute the traffic density at all time steps.\n", + "rho_hist = maccormack(rho0, nt, dt, dx, (rho0[0], rho0[-1]),\n", + " u_max, rho_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create an animation of the traffic density.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(rho_hist,),\n", + " interval=100)\n", + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MacCormack with $\\frac{\\Delta t}{\\Delta x}= 0.5$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once again, we ask: how does the CFL number affect the errors? Which one gives better results? You just have to try it." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the time-step size based on CFL limit.\n", + "sigma = 0.5\n", + "dt = sigma * dx / u_max # time-step size\n", + "\n", + "# Compute the traffic density at all time steps.\n", + "rho_hist = maccormack(rho0, nt, dt, dx, (rho0[0], rho0[-1]),\n", + " u_max, rho_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create an animation of the traffic density.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(rho_hist,),\n", + " interval=100)\n", + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Dig Deeper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also obtain a MacCormack scheme by reversing the predictor and corrector steps. For shocks, the best resolution will occur when the difference in the predictor step is in the direction of propagation. Try it out! Was our choice here the ideal one? In which case is the shock better resolved?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Challenge task" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the *red light* problem, $\\rho \\geq \\rho_{\\rm max}/2$, making the wave speed negative at all points . You might be wondering why we introduced these new methods; couldn't we have just used a forward-time/forward-space scheme? But, what if $\\rho_{\\rm in} < \\rho_{\\rm max}/2$? Now, a whole region has negative wave speeds and forward-time/backward-space is unstable. \n", + "\n", + "* How do Lax-Friedrichs, Lax-Wendroff and MacCormack behave in this case? Try it out!\n", + "\n", + "* As you decrease $\\rho_{\\rm in}$, what happens to the velocity of the shock? Why do you think that happens?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Peter D. Lax (1954), \"Weak solutions of nonlinear hyperbolic equations and their numerical computation,\" _Commun. Pure and Appl. Math._, Vol. 7, pp. 159–193.\n", + "\n", + "* Peter D. Lax and Burton Wendroff (1960), \"Systems of conservation laws,\" _Commun. Pure and Appl. Math._, Vol. 13, pp. 217–237.\n", + "\n", + "* R. W. MacCormack (1969), \"The effect of viscosity in hypervelocity impact cratering,\" AIAA paper 69-354. Reprinted on _Journal of Spacecraft and Rockets_, Vol. 40, pp. 757–763 (2003). Also on _Frontiers of Computational Fluid Dynamics_, edited by D. A. Caughey, M. M. Hafez (2002), chapter 2: [read on Google Books](http://books.google.com/books?id=QBsnMOz_8qcC&lpg=PA27&ots=uqCeuH1U6S&lr&pg=PA27#v=onepage&q&f=false).\n", + "\n", + "* R. W. MacCormack (1971), \"Numerical solution of the interaction of a shock wave with a laminar boundary layer,\" _Proceedings of the 2nd Int. Conf. on Numerical Methods in Fluid Dynamics_, Lecture Notes in Physics, Vol. 8, Springer, Berlin, pp. 151–163. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/03_wave/03_03_aBetterModel.ipynb b/2-finite-difference-method/lessons/03_wave/03_03_aBetterModel.ipynb new file mode 100644 index 0000000..eea7c13 --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/03_03_aBetterModel.ipynb @@ -0,0 +1,1718 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, C.D. Cooper, G.F. Forsyth." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Riding the wave" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We've reached the third lesson of the module _Riding the wave: Convection problems_, where we explore the numerical solution of conservation laws. We learned in the [first lesson](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_01_conservationLaw.ipynb) how to think about conservation laws, starting with the most intuitive case: that of conservation of mass. But there are many physical quantities that can be conserved: energy, for example. Or cars on a road.\n", + "\n", + "Developing a conservation law for traffic in a one-lane roadway is fun, because we can relate to the insights it gives. We've all experienced traffic slowing down to a crawl when the density of cars gets very high, and stepping on the accelerator pedal with glee when there are no cars on the road!\n", + "\n", + "In the previous two lessons, we developed a traffic-flow model and explored [different choices of numerical scheme](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_02_convectionSchemes.ipynb). Not everything worked as you expected, and by now you might be realizing how some restrictions come about from the numerical methods themselves, while others still are imposed by the models we use. This lesson will develop a better traffic model, and also show you some impressive SymPy kung-fu." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Traffic flow, revisited" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A better flux model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Like you saw in the first lesson, cars obey a typical conservation law,\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial \\rho}{\\partial t} + \\frac{\\partial F}{\\partial x} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $F$ is the flux, $F=\\rho u$—flux equals density times velocity. From our experience on the road, we know that the traffic speed is a function of traffic density, and we proposed as a first approximation a linear relation between the two. Thus,\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "F(\\rho) = \\rho \\, u_{max}\\left(1 - \\frac{\\rho}{\\rho_{max}} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This flux model meets the two requirements, based on a qualitative view of traffic flow, that:\n", + "1. $u \\rightarrow u_{max}$ and $F\\rightarrow 0$ when $\\rho \\rightarrow 0$.\n", + "2. $u \\rightarrow 0$ as $\\rho \\rightarrow \\rho_{max}$\n", + "\n", + "However, it leads to some unrealistic or at least improbable results. For example, note that if the traffic speed is a linear function of density, the flux function will be quadratic (see Figure 1). In this case, the maximum flux will occur when $\\rho^{\\star} = \\rho_{max}/2$, corresponding to a traffic speed $u_{max}/2$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![velocity_and_flux](./figures/velocity_and_flux.png)\n", + "#### Figure 1. Traffic speed (left) and flux (right) vs. density." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A good question to ask here is: should the maximum flux on a given stretch of road have a strict dependence on the maximum speed that the roadway allows, be it by physical restrictions or posted speed limits? In other words, do we really expect the maximum flux to increase if we allow arbitrarily high speeds? \n", + "\n", + "Probably not. But there *should* be some ideal traffic speed, $u^{\\star}$, corresponding to an ideal traffic density, $\\rho^{\\star}$, resulting in the maximum traffic flux:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "F_{\\rm max} = \\rho^{\\star}u^{\\star}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Let us improve the initial flux model by taking this observation into account. One thing that we can try is to introduce a flux model that is cubic in $\\rho$ instead of quadratic:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "F(\\rho) = u_{\\rm max}\\rho (1 - A\\rho - B \\rho^2)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This new model still meets the first criterion listed above: $F\\rightarrow 0$ when $\\rho \\rightarrow 0$. Moreover, we impose the following conditions:\n", + "\n", + "* When $\\rho = \\rho_{\\rm max}$ traffic flux goes to zero:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "F(\\rho_{\\rm max}) = 0 = u_{\\rm max}\\, \\rho_{\\rm max}(1 - A \\rho_{\\rm max} - B \\rho_{\\rm max}^2)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "* Based on eq. (3), maximum flux occurs when $\\rho = \\rho^{\\star}$ and $F'(\\rho^{\\star}) = 0$:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "F'(\\rho^{\\star}) = 0 = u_{\\rm max}(1 - 2A\\rho^{\\star} - 3B(\\rho^{\\star})^2)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "* $u^{\\star}$ is obtained when $\\rho = \\rho^{\\star}$:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u^{\\star} = u_{\\rm max}(1 - A \\rho^{\\star} - B(\\rho^{\\star})^2)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We have three equations and four unknowns $A,B,\\rho^{\\star}, u^{\\star}$. However, in practice, the ideal traffic speed could be obtained for a given road by observations. Similarly to $u_{max}$ and $\\rho_{max}$ it will therefore be taken as a parameter." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Solving the new flux equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Equations $(5)$, $(6)$, and $(7)$ are not incredibly difficult to solve with pen and paper. Instead of following that route, we can use [SymPy](http://sympy.org/en/index.html), the symbolic mathematics library of Python. You used SymPy already in the [Burgers' equation lesson](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_04_1DBurgers.ipynb) of Module 2, _\"Space & Time\"_, and you will learn some new functionalities here.\n", + "\n", + "We begin by importing SymPy, initializing $\\LaTeX$ printing and defining a set of symbolic variables that we'll use in the calculations. Remember: variables are not defined automatically, you have to tell SymPy that a name will correspond to a symbolic variable by using the keyword `symbols`. This behavior is different from many other symbolic math systems that implicitly construct symbols for you, so you may be perplexed if you've used these other sytems before. The reason for this behavior in SymPy is that the system is fully built on Python, a general-purpose language that needs you to define all objects before using them." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sympy\n", + "sympy.init_printing()\n", + "\n", + "(u_max, u_star, rho_max,\n", + " rho_star, A, B) = sympy.symbols('u_max u_star rho_max rho_star A B')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that we used the special character `_` (the under-dash) to create a symbol with a subscript. Here, for example, we've created the symbols $u_{max}$ and $u_{star}$, representing $u_{\\rm max}$ and $u^{\\star}$ ($u$-star) in the equations, and assigned them to the variable names `u_max` and `u_star`. SymPy also allows you to create symbols with a superscript by means of the special character `^`. Be careful, though: SymPy is built on Python, so you denote an exponent in an expression by `**` (this may also be different from other symbolic math systems that you have used in the past).\n", + "\n", + "Next, use `sympy.Eq()` to define the three equations—corresponding to Equations $(5)$, $(6)$ and $(7)$, above—in terms of symbolic variables. The function `sympy.Eq()` creates an equality between two SymPy objects, passed as arguments separated by a comma. We need to remember that the equal sign in Python is used for variable assignment, and for that reason it cannot be used to build a symbolic equation with SymPy. That is why we need `sympy.Eq()` to create symbolic equalities. But the equal sign _is_ used to _assign_ an equation to a name: here, `eq1`, `eq2`, `eq3` are names for the symbolic equalities we create with `sympy.Eq()`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "eq1 = sympy.Eq(0, u_max * rho_max * (1 - A * rho_max - B * rho_max**2))\n", + "eq2 = sympy.Eq(0, u_max * (1 - 2 * A * rho_star - 3 * B * rho_star**2))\n", + "eq3 = sympy.Eq(u_star, u_max * (1 - A * rho_star - B * rho_star**2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check this out: you can display these equations in pretty typeset mathematics just by executing their name in a code cell:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVwAAAAcBAMAAADfFxrHAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJZjLNVN0i77urRHZ72Yd1AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEcUlEQVRYCc1WUYgbVRQ9ycwkmWQnOyqUtdZmrG3xQ9Z0UfGrjIIgWmG+RESbCDatIHT/BME2FquLKMYvQcVEsfhTShRFcT+M1FawIQ3WQikLGyNSsWuS1da6tOt630wmmTeZSabdLvRCZu4999wzd957816AG8WmPldvlFYC9CEUxrIBaNeH8syqZWIFaWmESGNEPnBaKgem+hFjdXnZL9fF50bkA6cj12PZRRdHPE/QRxCCpieDEofxYo1hWZZ7hX4333vfKNqovOwalydGFXTzO1aq1dm6TZ6yHd97kzK7MVHwJQRLCBrP28uH/tFlIHyxmxY1fx4Q/YiyRUAsQciSuxqLT3PV4tsBl7J0AVD+6taewmlOxQr2WbcNd7MJjOlIVDByjXvIcFCGb+/dewJOV5K2LvE/S0ra/eJnnKgVdNtFkrUbLmO8AuWSB+9qoEd5cqNd5wG/KFEC1rPvhyy+stKxPO7KtZssIaVB6b5gn6dMHusHtrdxEjJbQYO2lYMUdb9OgKcGR2RDJb3JZuanBYPP9CKuXWURxTSkvykr5EzTTOIUzvYKeo72EpJeAwDM9jjMuR2ZBt08NVi+b5la6+tpCgVNKfVRzuPalS6iqFntOkliHsW6E2C+rG9FouxGzfgFDq0zTYheGhwPaBcQOkzYI/A90bh2iZXyWAxxHfPsrTkL4QjiDQ6ygwNAaM8M2WsGIFWrJ+mtPDWoYB3jzewyS7+ha5se9InP53N/LvdGLmcOhvmpyZfY+om6P7V5lb2422jlZKgdD+NGV6FWs4C3Bl98hcJ2GiTM9ghPc48uza/INgnBfOuZCiu6C9iDhx5uaa0v6dRb2AWhufMYwnm0MQgTn2tXp/2x5KdB5L6xbRcn60w4ku/DnMe1S//Z6JgIZzkGcAC0qB+/gMPqAkIHpUX8MpZ9i+3Qs6I6AFPtCUe9TJMb6fhpOIgwh1Sigy2m+U0bwLVL04DXsd41xaHLmNDljXks406ENSkPI6KzTVr5WBiEqYM/HF28R35iCT4aDiK9VQk4S2dDqhx6FeLmnc3keQOhyeMGtm+xdzauXRpa3NJy77HRpdYWYKwhlehd4tPJCjBeoK/p6LmnfxuEYa5Tupp228qziH77r+ajYdPYfWzvleqJr8jZ/2HTgDivx7+jR00YGTWpHo/VLWq33fCP/3xvnmoWyl2txRE3kmW5Y6QKiQdVZGDPgBcc72o7VIZqOHjMNU+Zd37HeD2cxiY8CQnP2RR7dM040rBh593aroo0kGI5HTcyP8udB5DuMrxgeorbhmq4yEfMuIanEJvGp1igsLdR3OrkplRnZPtFg3lziBTko6pS27c5VDv1q830gqUSK+BsqAbHhGz9hTyE8yhKoSV8cROkjsRzrGiHF4gznugw8IeB5FVoKHlWLXdQw2MCDknLelHICwOKBBz0Aq8BW3cNNa4SpYLn8cE2zJ1r6hv+3L7NlWahOLjmPFgBoKgWgLRqyvurVrAFXradtbzfsZbia6L9P+CaZQvZEew9AAAAAElFTkSuQmCC\n", + "text/latex": [ + "$$0 = \\rho_{max} u_{max} \\left(- A \\rho_{max} - B \\rho_{max}^{2} + 1\\right)$$" + ], + "text/plain": [ + " ⎛ 2 ⎞\n", + "0 = ρₘₐₓ⋅uₘₐₓ⋅⎝-A⋅ρₘₐₓ - B⋅ρₘₐₓ + 1⎠" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eq1" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUAAAAAcBAMAAADihXuhAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJZjLNVN0i77urRHZ72Yd1AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEl0lEQVRYCcVWXYgbVRT+kplJMklmdqwgbVnMdG1F8Id0qyI+LCn0oeAK8yi1uBFsiiDsuiAKQjdVq6UIxh9QVEwK1opYiSJUXKUpaBFdtrHqSy007ItCt/ujtnWxazz3Tia5szOZ/BTseZh77jnfd+bON+feGeA62vBnxnW8e+dbS4VktjOqR4RS7ZEQAI8VlJWANKVqwWm/7MN+wT5jsaq6Gkw9F5z2yz7qF+w7Fl0OpkqZ4Lw3G655Y9cQiXUqt5+Kr7v7nu5vUWxtO3Vo2uJEJdsV//Vtxwk3Wp+ZmW728XAn5hwB9mJ9oROumRcqDkKyOyiy1EwHOKqJqQzl/wHClxo42Ww4fkP0MEWLgFyClCW3Ozvagp0EPuKznR0ayaboVzCQB5S/AO2PRpWf8EvDE4Z9tj94BysbyyBRQadWbbEVYS0fAqfZO1YnO5wVNl07hlQW0Aks/2uHlL1Pf2p74rWxQOjsXuEyBirQroiAIJ/kbtq4YS9Q1zucFU0Ge8WJErBxvx2K1+s+3eFaoF5CyoTWeCKnUmiuhrcNZyaO4aw4wysM9GOU3hpwZp7JGWSh5ylLeigvM1pbvGuB2jKKaSh/EkHKcTPJDUdLWKTRa4myGNMYL1RV2PNJplYSc15fvW8TBcdmF76YoLE93rVA5RKKpr1AoeIbJNS0MG+5kUrLpw5mMw0q6/mdaHwVIu2FvL8KLBYQ+ljEk+821wKpaMr7io14DZ+4WY1ZzARuOshsD0WGWHT3zAydHHjf6eSUwaKOtcAUiR8GvqRxkSRs4h2kPd6byx3K5Z5gE75JVNr7tIvXbpLzBknrZ5GKENVNNiFVPiAdl/n+pPkzLOhjagEJus9VSi2mBbxH8bUKUlvJbENLXJiDFVb7NuhLkDc/MqdfsBC665SFkS18D0R4mkHIJkE3lck5RG2bRyQPaWHitRe3YN38HozumC9wlHMZWGYLZMcgTlcbeJZzK04B1wLpd0cugVrObV8hUd4un8/ET+oVrLfGDN04FSOpkCy3gIoJvYA3KTBO7WhizMKdSpk+TKEDdFw+uMoJLXi8jNgKl1mhlrDxLOtR3LVAejN4CRutVh3u3Y6zZvrV3zFQDaep0x6Cgsd4go6lpr21bfg7qCxwooBUOfQCMP2kgRWETSWv3iw8CqfIGUzVECH8WTqdbbyv4q4Fkny4ceFbXkG4DI48NWthFrsQm8BRzFPK/lqwB3JsvF7/O3TisoFn689h6r05esrddYsOm/gE6Z6sOThnPDP0NZLjV2d+OE4RG++reGOB4e8vf8O/JA7fOx7BBRSV0Ao+vwHKksIBx7wwHrmVXaOFZE2vbEgVEtuN+Nq34iZyvL/ijoKcEKm5eeJMXSINH5BwRFnNFKW8xHO3iAjB56dSzApb4Vo6bo39zH5Dgsw+xXwV3yDyPFtISGoVPI53t+Lcb3OZwYsjW3lqlwAQXJWfSvKOi9BmLW1232b8KmS9ro3vQvFRLzc4kpzwzWt533DboI3vQvEDbUu0SYSybRL9hDsrLqd7rjvZM+NaCO/0To5We+f0z9jUP/V/Y/4Hu1hQx0wMtJYAAAAASUVORK5CYII=\n", + "text/latex": [ + "$$0 = u_{max} \\left(- 2 A \\rho_{star} - 3 B \\rho_{star}^{2} + 1\\right)$$" + ], + "text/plain": [ + " ⎛ 2 ⎞\n", + "0 = uₘₐₓ⋅⎝-2⋅A⋅ρₛₜₐᵣ - 3⋅B⋅ρₛₜₐᵣ + 1⎠" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eq2" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU0AAAAcBAMAAAAXe/ARAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHaZIu9UZs27RDLdq4n9ARY7AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEDklEQVRYCc2WXYgbVRTH/zOZJLuZ2exUW+iDZUMXhS1dNtSHVqt0VNQnSfChrVQwbamgLZg+SLFUXURroC1NEZEVpBEREdEdBF9KSwKlWnAf0hTK9iF0u33Qx6xd/FhZ47nzkcyd7+0utOchc+85v/u/Z07unBngvtudT9T7nkOMBLLa0GQMbLXIhdUKKJq8GK4hhodjReVqLCwEUmrSUkiYQplmeDxOdGANzlZqIWKn3yLiMcLbYjBRiJKLIJRVF0NylUKejNjSDKdvLbdvfm6jd+xB0FXMB0Xi+rMuhYFOvJXDVWCXbrJplwavcEgFpA7vW/ksWeLXnHDVl4/2Z/UyMG3l9wO+6wfs0QFzIFy/RXniF9t9r9c6U+mbdDCixdjohAa8nzNm8snXz9nu/tXKE5hgOzzRD9zb6G1+mShGtBgb/xQQXjXvMdntdmx3/8rn+Sjhozk8z1elT1ujYGYHz36Z+os5vhrXeb9ntgxcvBZG8nlOq0ikipjw6JAjWzEsT8NABlPcSqEm/8FW5jNFzu+ZyMubx34OJfk86zpeTEzauw0EVcHBuLY8w80zkO6S4wSsN0ygoEjHeEPTQXIybMLnWahBTebwsomNqB7cdDgYF3GZ5htnmJ2i0aV2+x+67EHmT4PjBIXTDLtq1GKwCIjE9EgD7/38XqlcqVTMGhjPUaFE7UGV/zWJIz3QPegzrghfzxqwl17HC2D1IgsUHKZaiv85SE/lPfXEUxA7dKY2l567uhMPj5/Cu8fGNdoky25/ZoYUYTLp7T+OimM6hG2zOuZ3Gs8Kl2eayCt0mhsYaPgIMiHLWPscWrJI5uMqzxx8nnUN+AKD1aN4Uq7iJIRf5QUcX1JqDHWYwaSny8lrYhOP6HVVVGcN6KYDwgs0OQsoedC5DxWc0IB61SKZhKfyfJ70vFMP/To/h6n9KhaRyMsN6aEqW8mZwTyzFcO1xBwex0XI+NgAqLH1TCrS8LyGkapA749QwY/odLyiWqT3ryQdPk/WpjfNH27puNTVqZkkS1SvoRx5eTOZFn6CUsJujFPUPIHsRi0Tzv+t4o3uZbz17KhOz1SI4Gy33Z4qwSJ9K2/n+fRrZ8qO91FKG8qJzfUj2uBRNUm7+No+jKEgC4v4bB3kjsyYZI1+XGb0/liC5lvCt/J2nqb2B/YWip7QE7m5pF7/BgXb6brSV0sL72SxT14qF7KNLAvTMfCY0eXiCFr90Lfy652yQu/rJn1sCzItPdM6sB3fOhHHmD7/P8RLt/H9Y6PlTVvmb7OQXHQA5lAyulwcQZOMUfl007PLSh03PAsyDY8rwGGSMSqvBJ3EAGEf90Yf38pcMSr/3soU/ehU3s+7tj6pugZ6b66BRoREQo0AHqDw/yhNMkunLpUAAAAAAElFTkSuQmCC\n", + "text/latex": [ + "$$u_{star} = u_{max} \\left(- A \\rho_{star} - B \\rho_{star}^{2} + 1\\right)$$" + ], + "text/plain": [ + " ⎛ 2 ⎞\n", + "uₛₜₐᵣ = uₘₐₓ⋅⎝-A⋅ρₛₜₐᵣ - B⋅ρₛₜₐᵣ + 1⎠" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eq3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As stressed above, we have three equations with three unknowns (assuming we have some observed value of $u_{star}$, corresponding to the ideal traffic speed)—there must be a solution!\n", + "\n", + "To eliminate the term with $B$ in `eq2`, leaving it only in terms of $A$ and $\\rho^{\\star}$, we might subtract `3*eq3`. But this will not work in SymPy if you attempt equation subtraction using the equation names. Just like we couldn't use the equal sign (which in Python means assignment) to create a symbolic equality (needing `sympy.Eq` instead), we can't use mathematical operators directly on the SymPy equations, because they are really _equalities_. What does it mean to subtract two _equalities_? It doesn't make sense. Try it ..." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/latex": [ + "$$\\left(0 = u_{max} \\left(- 2 A \\rho_{star} - 3 B \\rho_{star}^{2} + 1\\right)\\right) - 3 \\left(u_{star} = u_{max} \\left(- A \\rho_{star} - B \\rho_{star}^{2} + 1\\right)\\right)$$" + ], + "text/plain": [ + "⎛ ⎛ 2 ⎞⎞ ⎛ ⎛ \n", + "⎝0 = uₘₐₓ⋅⎝-2⋅A⋅ρₛₜₐᵣ - 3⋅B⋅ρₛₜₐᵣ + 1⎠⎠ - 3⋅⎝uₛₜₐᵣ = uₘₐₓ⋅⎝-A⋅ρₛₜₐᵣ - B⋅ρₛₜₐᵣ\n", + "\n", + "2 ⎞⎞\n", + " + 1⎠⎠" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eq2 - 3 * eq3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "See? SymPy just printed out what you suggested but it did not manipulate algebraically the left and right sides of `eq2` like we were aiming for. What we _can_ do is create a _new_ equation, perform the left-hand side (LHS) and right-hand side (RHS) operations separately and then recombine them into our desired result. For this, it is helpful to know that there are built-in properties of a SymPy equality for the left-hand side and the right-hand side of the equality. Check it out:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqcAAAAcBAMAAACuWQuoAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEM3dMiKJu1SZZnZE76v5rQUQAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAHxElEQVRoBe1Ya4gbVRT+JjuTzWOSnVpEpNpdWwUfqNFWsT4H/SGibdIfPqrUXRErWsT8ECqiNqKiotLUFpe6UiOKYm014qNdVndHBKVCu1st+Koai+/F7ba6WrU0nntvMrkzmUxmVtH+8Py4c+453zn3nDPnzr0JcKhStH/1IRjaoRlV4ELdgN2Bsf8e8D+I6rJ/MLszkM35uyv7qz20quUhDCVqG1UylLsAYDUfABQUci56LX/sdn+1h/ZiD1k4Uduo9Eo4h23REaMtJAxgVRt30VIYbwx7TFgDD3y7qG6WbLRlNxak6bTYgYbVkv7bxOTChsyHE6sn9hyc+O5OG3aOzbVgTnPLr1h2u1skz+POD4baIytb8iGj6pBaYQlif7T0G0yh7bVxSgW3Wnx2qi3zY2qrd+WBp8waMFr0sYjtIOWgC6AVsarkksnTXilfkkcmZWVrPnhUj9ICSSnskQJ+bu03kEaqQtpAaowZJS6gddpTbfVsCRitB/WCh1msLISz17MX2OtCJPejK+OSydOb5AnwTKMJnArXLGhUyg97KFltsmG+zVL2NWbT4lIF2yyVQfoXNrvqqZwt9GFqq48Q+OWywOl9utlkUS8qkqwgHSUnQN+F7h6nyDH72DHTHppyzFtOgkc1YpCTs2VHf3v7Z5lLQZG9taKWR6y6zP/JV78LUD6sebnwwQca/uq2zqLG83W5/fTb/qqzM5PJA7aZLxM8Kl7UftnZzD7MGoC2Q5Z58K0xmxzoDpaCbvAs9YGvHTqPCa0OHAQu+oqeDP9ltdoMcxY1OeZGKGdCGSxjqeFWsHnCCX9bdNHWYdMLLMmCR8WL+pZkesUCA8VHkZyUZDYbncOpSIKWGDxmwxkz2kfDUciW6XETttHoR2x1qAeHNp/FUC3xzqLqztaj79n1qxGPjWHEc6l4jyxWLPVPmkeL+pgsbuZDRMWLOkqZ2BTdpZUeQ2feFngyPpgVDoPz2cxCb5FaJNP2Io/oLjo46SN3dMUP7yyqyj/bjlVvsa6m2jkjqQOcqenQfifNM9DafAVCRMWLmjVx2DxGx7KFP5+Bz5Aqixi4RLCOUZEwDgVwCn0R5zJvp5tAnIoJdWJiTx5IlTBa4GCH1waY6T430DlGhd0v47lRfaDtMveDOXMqbM4PKlEOKQMy3WFQBp/VTRzPSAVSuosmJn4j9afQaUWiiEmDTZLTEFHxoko/BC8HVhZoP1GdGSnuncWlbGhgbFGNWSALBtlEpyx76EtggJ2gPl756uiqULV+lfDMxkHOTtVEOWyElkPnflrNo4MZpoO9Z5ss4AOeDetEom6DP5qHEFGJohZsH1WDihrP1D9HsYytYUyUNeC8eRViGximkIk61aZYEVSoEmUyBqwB5nKNy6uNBl8d7EKYps1o4+HobIK7iurauF17WVHXtDgXwDrVpgRx5/FsIiLVe22ViwkRlSiqZTv4CLgg11nBioSB5Vu0NSeYysBuM/Hji9/YEMEIzAvPDhWH6JfokcPHIjp46ddMJxf1EuB1aAXxs2UBWO/4eeWr83bO5gGBJ49N+8VZVFX0GFubUyqPjincTefC04knLh1MbjbBksDytcMmARxFvYoE9GuPupf2ZnSosOT0tTyZlzYM50glEdtkAaPiRc027Dcg9ifief2TKOLWxYgUMNPMGolR61zJP2MFZuMf+MIYhjKfLn+vpHs46LsGUjtz2foMlpKgcwrKb5hZ8vfKV8fJtB0/Mmp45qyps51FdZ/+iRJWldGPbcW+xGgp9VWywpNIGrs7LPKWpvdVJ22MuJU5dOcVuqw/qeZxvEhm4wGOrePoGSIqXlTp9NfX9VtQvt2y6DV03j4DXTmsw0VYvFnyLliO0WZlcACP03GkZmBGSlwlXdAi1Wo1c0T1GMRW/lyMTQ2tper6eeWr765OTKwoUCk53rOz60WN/7Tvx6aLJ7B13Z3A7OX3jZuLX0WXFe/jSag4kceXZIUUpKzcZ+CB6gKsumbQBFbcY2CKJ6PNkirPsSGiWv/lKSVgk1jCNap7fmH3yo8xDIy7dPVpuqyO4SykCtQN7A0wkl4Rn9cHuuMQBfEqLATec7/Ui1oDugsgxHwcx0J0FEQSVDBG7sZmMnG3XlQ16bbKk0mXmdiDAkfV72EM3E+lHFYWT+GOGdjpiaBD3UzmtUmzO9f5tIEsTAZLWWxsJnFLC+JV2Aq8Z2cr4vXV1oi0KgDpd2IzelWFJ6FOqtxiV81OevDLVyyXLicrh/NkUqakldnAUZ0kW9n8fKzFQBQ71QMl+S8XW8+YXqTLiXxfysy+r01ejz4mo93mSb0mEwfxKswFPkBndxvCwGOkwMfxvEiiN5qJcsjjTUCNDlA6rcy4GS/zZJr++bJNgkbVdLgKDxtetLD9NWzfMljS87ZTJ7MdkZz2raGPP/yEMv7uGzw7+iB40jtcGsSrMBf4AJ39kudyXKhXcByuvY4nMfvN5ddx4cImvJ5hosSGN6GPmywZvNeEqQmCRpWotPIwPfn30zPztgrQ2fO9LVtK04WWqqCK9lF1mEF9BcMdFgwWDNW+sxN9wTzZKKXHZqfLtI/quem6bmFHP6P+Tboy9GIPhbYIbaDlQ5u0MXikjf6fVa8O7S5mhTYJaxA3wlr8jw9Ugb8A3N+rAKBcUOkAAAAASUVORK5CYII=\n", + "text/latex": [ + "$$- 3 u_{star} = u_{max} \\left(- 2 A \\rho_{star} - 3 B \\rho_{star}^{2} + 1\\right) - 3 u_{max} \\left(- A \\rho_{star} - B \\rho_{star}^{2} + 1\\right)$$" + ], + "text/plain": [ + " ⎛ 2 ⎞ ⎛ 2 \n", + "-3⋅uₛₜₐᵣ = uₘₐₓ⋅⎝-2⋅A⋅ρₛₜₐᵣ - 3⋅B⋅ρₛₜₐᵣ + 1⎠ - 3⋅uₘₐₓ⋅⎝-A⋅ρₛₜₐᵣ - B⋅ρₛₜₐᵣ + \n", + "\n", + " ⎞\n", + "1⎠" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eq4 = sympy.Eq(eq2.lhs - 3 * eq3.lhs, eq2.rhs - 3 * eq3.rhs)\n", + "eq4" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That still needs a little work. SymPy offers several methods to help reduce expressions. You can use [`simplify()`](http://docs.sympy.org/latest/modules/simplify/simplify.html?highlight=simplify#sympy.simplify.simplify.simplify) to attempt to make the expression \"simpler,\" but you can imagine that the quality of an expression being simple is not well defined. One may expect the simpler expression to be shorter, maybe; but not always. The SymPy `simplify()` function applies several strategies, heuristically, to give you an equivalent reduced expression. But some expressions are uncooperative and `simplify()` gives up, returning the argument unchanged. Let's see what it can do with our expression `eq4`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAAUBAMAAABfZ52GAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEM3dMiKJu1SZZnZE76v5rQUQAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADLklEQVRIDa1WTWgTQRT+Ns3mZ7uJ2/YgUsFq66EguNgiFsQuehARTIr404MkWKgUD+agKL00IJ5EDLZYakBX8WLrIULVlkKyIHgQ2kQQVKxSRHuw0Ca2RaiFODOb7G7bJI3RB9n53nvf+97s7MxugP9nvPqXWoLfLOC7L4RNryJ0Rq86XFZx5+Bl4LtJ7YRrxfQqQrv1qr3lFHMzuKSh1qQmwlg0vUqQEGFVQrtURrVXgicFR8ygTmrcT8OpCFTpT/PsA30sreGR4V0Cl7Kw/nX9T+pasYRmES0GbRnaH3ss+bog6qPg31pChWBRzjhji9JtlQAx+q1QsTVWlQF6zMDpNgmRW6hOmyETnd9FrZkGinJ6GX07fDECejDJ3BKXZBB4ZMk7pnn1DpwhPdRkyVihlWONAweYqyEQAQQZAY35xXSAQyR/HbUt1Bjrcw0+wUNnD3BkcQoaZ3LW5aepb5+fXyB34FGRDFN/rQ7XSJvtU2jGTaYJH0XMTgF9YTEDn8Jcl6yHN15Nzroc6y+S3g1AUkLCT/PFddh2MftnJdLfLSNBii6O8f3NChf9qgg/Rtg7qovOu4WuGHTOk8cTkQnyBtsWb4Jj/DjdbGz9VaAqBfQDjYV0qIBurgjILb/Ku3gPtPudM7gqSG7tKGxh1Ck+SUhqBw2KDnTO0xV8keLgWu0ZPPM2UBLdf3wYsKWBNtiXUFLnGPDcuv+G4foNd0j86IDzWg22+DGEI+h4SUTXGuPw9TJWcZc8RLsMxaZSCj1L58jPuQzuF+rUkjr8/u77MohC3sShQQ3c7NiJUdgXlujp+YA4MJfPG6PO8cbsKbLinnD1DOhkiZG13JrdCVffYsS1PDFA9mIJHVs2myX9C56OG6RrnOtYRm8N3hl91wKPUh3i08oOv/OhRHaxQrK59y/luRvodXMdnkxho7ViAFEH3tlXVT69Mc0iAXhjQijoUXxv+HQXgiSY+/7QtH6IN9exfH9oWc6GRzRMjWJqbFwVQ/ngunEKNj8/K4lzN+9xc69fSDR9xeAEFAo317F8f43aykHu/wcRMI9VaTVzxqV55WV5tTyewRL8+AOV5Or39L6DcgAAAABJRU5ErkJggg==\n", + "text/latex": [ + "$$- 3 u_{star} = u_{max} \\left(A \\rho_{star} - 2\\right)$$" + ], + "text/plain": [ + "-3⋅uₛₜₐᵣ = uₘₐₓ⋅(A⋅ρₛₜₐᵣ - 2)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eq4.simplify()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That is actually a useful result. We see that `eq4` allows solving for $\\rho^{\\star}$ in terms of $A$, for example (remember that $u_{max}$ is known: the road's maximum velocity). Then we could try to manipulate `eq1` to solve for $B$ in terms of $A$, as well, so that we can substitute back in `eq2` leaving everything in terms of $A$. We can do all that without the help of `simplify()`, but using it interactively to reason about the long expression helped us to decide on a course of action.\n", + "\n", + "Another SymPy function that can help us examine complicated expressions is [`expand()`](http://docs.sympy.org/latest/modules/core.html?highlight=expand#sympy.core.function.expand). Its purpose is to expand bracketed factors in expressions and group powers of symbols. Let's see what that does here. Notice first that `eq4` hasn't changed; we just printed the result of applying `simplify()` to it." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/latex": [ + "$$- 3 u_{star} = u_{max} \\left(- 2 A \\rho_{star} - 3 B \\rho_{star}^{2} + 1\\right) - 3 u_{max} \\left(- A \\rho_{star} - B \\rho_{star}^{2} + 1\\right)$$" + ], + "text/plain": [ + " ⎛ 2 ⎞ ⎛ 2 \n", + "-3⋅uₛₜₐᵣ = uₘₐₓ⋅⎝-2⋅A⋅ρₛₜₐᵣ - 3⋅B⋅ρₛₜₐᵣ + 1⎠ - 3⋅uₘₐₓ⋅⎝-A⋅ρₛₜₐᵣ - B⋅ρₛₜₐᵣ + \n", + "\n", + " ⎞\n", + "1⎠" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eq4" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And now we print the result of applying `expand()` to it." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARsAAAASBAMAAACZe2duAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEM3dMiKJu1SZZnZE76v5rQUQAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC0UlEQVRIDa2UT2jTUBzHv2nTNEnTLXMHD8qY/w56MTARBuKCHkRE1x0mTpjtLhPpwR2EiQeXgx7F4gZjFjSehO0ycLIVZQ143jphoDKFOtSDg611K4IK9SWpSZc1ey34oM33936f7/e95iUFKiM0eF37p+nXM3TEn+gbv+XfrHT6wP+iQg5w3FGNCyaPmwbNltWwSWOcvtglO7ph0SQjukRzLRjMDxrj9K88jTm6YRFV0LRFdzVwWNNZg57nRwSKdW2nNYF9aYTe+sW485L8UCeVlP7iztmKyUyjn36QwSIVvNwpI/UAkYJ3CbPmDlojZff2o3uaqBtYsGv3W+CXkHVLP5VL0EHuY0h/hPCQnXHYL4rMG4iTjYkK4oZFuexVoR3DuzgrrdPwA/d0mMMK/NSCFUTN3w0wxYqzxoVdX98gm47qyGlmu4qViX2lhgWoWgdCCv6g7e4FRjSpiG7VqnmlZqg1KZGttAM5GdmYOVHN5mSW/tZkiIkClmWyHUGxTj45Fxo9qjLpVVX8PvXVXJGz7mFH3tTQgeASMAocAjzsqPnwiY8vZCKzKswEJMfmVWKqGnwKvcS9K/gO6IqF8xgWZcE4h4CGVrVbFnPGqaogS4Y0IFAAOkFuhJe9Sx6+Z2JOj36O5K2EiLwaNLZHnAdeggJOgv8NYUj6wCF8uwXNMUzgLHpmtyeZVT/5hEtgfqJV38GOYyGV6HmBZkNIWAksjnkiQicHnyiggNLEuAHm29ylGbAbW+Yr/B7zwJonC9hbPgB+ZDPFl16NYQfblry3phLXRQQ1OwElT0SgXC4rqAOs+O6TuHmmp4Q7LVj2ZLkleaXJqM0uYxZxlrES2ALrmryqHvAExpDmsMz+0UPkGfEZ9j9CTZa41vDcTohzCueTANQFTk4ZWJzB4lxGl4Z8o+Kq2arJSnkcwbUBK6HtdXLAN6Nu0DfBabxx1H8UfwF+8A4hLuci+wAAAABJRU5ErkJggg==\n", + "text/latex": [ + "$$- 3 u_{star} = A \\rho_{star} u_{max} - 2 u_{max}$$" + ], + "text/plain": [ + "-3⋅uₛₜₐᵣ = A⋅ρₛₜₐᵣ⋅uₘₐₓ - 2⋅uₘₐₓ" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eq4.expand()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's very similar to our previous result, except without the bracketed factor. Simplifying an expression can be accomplished by expanding or factoring terms, or a combination of the two. Whether to `simplify()` or `expand()` depends on the situation and you just have to experiment.\n", + "\n", + "We now have an idea of what to do with our three equations. We'll get expressions in terms of $A$ from `eq4` and `eq1` and substitute them back into `eq2`. For that, we can use the SymPy functions [`solve()`](http://docs.sympy.org/dev/modules/solvers/solvers.html#sympy.solvers.solvers.solve) and `subs()`, respectively. The arguments to `solve()` are the equality that needs to be solved, and the symbol to solve for.\n", + "\n", + "**Note**: `sympy.solve()` always returns results in a *list*, since you often end up with multiple solutions for a given variable. These linear equations will only return one solution, so we can skip a step and ask right away for the `[0]`-th element of the list." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIkAAAAuBAMAAADuEyesAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIpm7MhCriUTv3c12VGZoascqAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADDElEQVRIDe1WXUgUURT+ZnZmd9b9cRUseigXlQITWVB6K4cCoRB2CPTBhDYofXCphRAhFpqXDF/apSyKCgaR/iCy8Lm21bYIxe3nJehhqYQIkbVckBS3O7M77ezsaOPmo+fh3nO+7ztn5t47zLlAdX0rzBg1eD65ro4N4KK4LqshquFa04TFrlWAPVoMGUezSfw2Zghql2BdWpfVEMMiu6IJi11HxmQVbLQiUrMiw8Zj2CUUly+NukPoaQJ1vZSRkUiIdkUxa0wW0J2jAryf4EwXIK13D3vocbRoIUPfdpNK7YfFlyMnijW0F4I9hjvFaD468Ui2fMatTqIiUtnYjDL9HeLEiwjMvw6qCmhLchn4eSXTJSmTOri8qEKjvFx3c0fcOcmDbernEW5I8KpEmbMCqUJLyv6FZ6jGZ7ysc5+dPyXTh4GXOECWO+eOpOxnnAF0837BKfRXiEq2OlwDnngsAbS4BVo8AkdS0bkj4gOioO4P7pVQj2FvqOYtKkU6hDocA4Pnanp+XoBrFbSPu2qD5WAnKj2KrmZSoR3ZbFZCV/hjkEcQR1GRxF0kCLWoq8LV1Ytg+2bap8CcW8IwcrqgTgaMYBK1DLuIQ51g0kwJrwLvyPMSbI2iG1FBdabShP1qwwiznKq1STYVL5nH0ICmnI7k6IwL4Cl2DGBoJp7qehMe0NGFcGFexNCUouPy32CB3Pa2fAfIR/ffVnLaW/6W2wUNdoAZNwA3DTm25PR+6H7xm34NOYF6r//VlVPG6VwuJ02Xc0m+q2zQlHVy45AVmVVs1JSN03QoB+ontE1Zx5sL23t7f4EtNGVzWXqVCNwGCk1Zz5uK3UT1EMg3ZVMpBqLdBHsBWJSm/OXbtHe6FTiemIAt3nHaQG8IUVECt3nyTfn7Gm4ICbBjTAavrONybzdjbNuKgA/Z0VxTpnokLGMfaC8jgXekzFQw0FhjTBSPYU+SO4l8UyjP7LzTR6X5kx7LnAA/+PKq1MIac/tCdt5/hUpfQKi8KkNweKg+gQt+bmaDl18LRlX+AMmUDdoVgcI/AAAAAElFTkSuQmCC\n", + "text/latex": [ + "$$\\frac{2 u_{max} - 3 u_{star}}{A u_{max}}$$" + ], + "text/plain": [ + "2⋅uₘₐₓ - 3⋅uₛₜₐᵣ\n", + "────────────────\n", + " A⋅uₘₐₓ " + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rho_sol = sympy.solve(eq4, rho_star)[0]\n", + "rho_sol" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHEAAAAvBAMAAAAm1DhkAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEM3dMmYiVJl2RKu774kc4rYDAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACj0lEQVRIDe2VS2gTQRjH/5t9JNl005WC+ILG1MehB4MPFEEc9NSDZEUPIh7Wk0iRzU16kC7agkXQiAcTU8yCCkKxqcWDoWAjKHgzh4qIB1O9pLcEa4QgxM3T7Cabjjl58DvMzPf/fv+Z4ZsNAdrjRHvyV+t9lPQ12Qbyx+2KFZiop8zLZTt36Y5qRW1Zwwkk7c5o0rCx1tTRKcqTiomKMy+shlbm6NyGcNSk8njWYq0LR6cBTQf4EDTD6mhmViczcsCM/QTglpaWM4CkIBVpsm3z12DwWDA4WlNsHRJNVwBIyUiqbY62pfXMPwWzO2wWuAGM4NzZuB5/A2xJ7II/NtZomYNTMK/oKgBHwK3j/A98lhNgDnJF3PUFjtb3d3BeMasDJTC/MKQIW0Mo4zY8OhcCcZm3qUV3547KTrjff9fdpfgU4ItyWRyGFPEuAIOqzXnry2hzs0alOnkC1VEi3oxQIMPqwGkZYZCqBrTOrKe2UYpWBc08lc/kJBJ+IhS+IVeHNtcnh1Ej1cIcXKrwShbTE9NMev6h7ABb5EeW7H8CVPqMwr/UvPw7qtfvvLJf9QU6VRqFVbkSDdfJsIZQ7lTpFHeRjuuk2NqvrVPfWMlvjHQneL273lt9miCYx+PeULeqXxez3N6rr7vVemtnIJSlSqWPT/oDxJ+993aoikV4+/t+PCG4Qg679pZZHWHSG3GoDmeYQ+Cnx2LeWQJmZpFgbcp8JoqYvBwj4FOK9Nz8TxkiYdkrL7IGhRHXq9DFexg0PDncxElw2E3jAz7VsDROgY3gIxJmStdqYb3mXMEsNI4p4e0mcAWO5lCx9iJCAWlc8GOFKyuaP+SncdYZcQF7ML6KufsxZfuDtdUuzt9xX83kzN9wtgAAAABJRU5ErkJggg==\n", + "text/latex": [ + "$$\\frac{- A \\rho_{max} + 1}{\\rho_{max}^{2}}$$" + ], + "text/plain": [ + "-A⋅ρₘₐₓ + 1\n", + "───────────\n", + " 2 \n", + " ρₘₐₓ " + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "B_sol = sympy.solve(eq1, B)[0]\n", + "B_sol" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The arguments to the SymPy function [`subs()`](http://docs.sympy.org/dev/modules/core.html#sympy.core.basic.Basic.subs) are given as (old, new) pairs, where the \"new\" expression substitutes the \"old\" one. So here, in `eq2`, we substitute `rho_sol` in place of `rho_star` and we substitute `B_sol` in place of `B`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/latex": [ + "$$0 = u_{max} \\left(1 - \\frac{2 \\left(2 u_{max} - 3 u_{star}\\right)}{u_{max}} - \\frac{3 \\left(2 u_{max} - 3 u_{star}\\right)^{2} \\left(- A \\rho_{max} + 1\\right)}{A^{2} \\rho_{max}^{2} u_{max}^{2}}\\right)$$" + ], + "text/plain": [ + " ⎛ 2 ⎞\n", + " ⎜ 2⋅(2⋅uₘₐₓ - 3⋅uₛₜₐᵣ) 3⋅(2⋅uₘₐₓ - 3⋅uₛₜₐᵣ) ⋅(-A⋅ρₘₐₓ + 1)⎟\n", + "0 = uₘₐₓ⋅⎜1 - ──────────────────── - ───────────────────────────────────⎟\n", + " ⎜ uₘₐₓ 2 2 2 ⎟\n", + " ⎝ A ⋅ρₘₐₓ ⋅uₘₐₓ ⎠" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "quadA = eq2.subs([(rho_star, rho_sol), (B, B_sol)])\n", + "quadA" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/latex": [ + "$$- 3 u_{max} + 6 u_{star} + \\frac{3 \\left(2 u_{max} - 3 u_{star}\\right)^{2}}{A \\rho_{max} u_{max}} - \\frac{3 \\left(2 u_{max} - 3 u_{star}\\right)^{2}}{A^{2} \\rho_{max}^{2} u_{max}} = 0$$" + ], + "text/plain": [ + " 2 2 \n", + " 3⋅(2⋅uₘₐₓ - 3⋅uₛₜₐᵣ) 3⋅(2⋅uₘₐₓ - 3⋅uₛₜₐᵣ) \n", + "-3⋅uₘₐₓ + 6⋅uₛₜₐᵣ + ───────────────────── - ───────────────────── = 0\n", + " A⋅ρₘₐₓ⋅uₘₐₓ 2 2 \n", + " A ⋅ρₘₐₓ ⋅uₘₐₓ " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "quadA.simplify()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It's a little bit ugly, but that is quadratic in $A$, and that means we can solve for the roots of the equation. SymPy's `solve()` function in this case will return a list with the two roots. They are long expressions, so let's print each root separately." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "A_sol = sympy.solve(quadA, A)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/latex": [ + "$$\\frac{\\sqrt{- u_{star} \\left(4 u_{max} - 9 u_{star}\\right)} \\left(- 2 u_{max} + 3 u_{star}\\right) + \\left(2 u_{max} - 3 u_{star}\\right)^{2}}{2 \\rho_{max} u_{max} \\left(u_{max} - 2 u_{star}\\right)}$$" + ], + "text/plain": [ + " ___________________________ 2\n", + "╲╱ -uₛₜₐᵣ⋅(4⋅uₘₐₓ - 9⋅uₛₜₐᵣ) ⋅(-2⋅uₘₐₓ + 3⋅uₛₜₐᵣ) + (2⋅uₘₐₓ - 3⋅uₛₜₐᵣ) \n", + "───────────────────────────────────────────────────────────────────────\n", + " 2⋅ρₘₐₓ⋅uₘₐₓ⋅(uₘₐₓ - 2⋅uₛₜₐᵣ) " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_sol[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAABBBAMAAADCnKbzAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIma7zZnddlTvRIkyEKtZsEGBAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAJT0lEQVR4Ae1bb4wkRRV/3fOnd/707HAKCdFz5k4IgYiOnB+IMTpHTk4NyAS4uwQPGCMY9AiMOdc9EZf1gxID5hYS/5HjMkEwuZjcTozLhlyInRgghIQdEtiLH7gdDHE/INzuGfWy3HK+96p7pqu7a+1bu2dnyFayVa9e/epXVW+6eqarfwsQfdoePeWGMJqduIY1qnEx95v36bgGPNaOi7nfvEYnnhHNI/HwbgTrdfEMWujEw7sRrKV4NsRccSMWE8+YMX3cX49ntjbrnef7mCC/GsditOU4WB1OreJY/Sl3xzFMqh4Hq8NZaDpWf8orxTBaOYrhdPsWlGlEwabi+KiqweXf4rLXb27jrqUmFx8BuPiWL4Qj+9iJa1XAt0RDycIyCr7AcW4L9EpO3ov5muRTVd44Yc/aDyjwR55pcctOwF/af276UX6PVoPDZb+bPa8L/2ewiIQvaBizGuSVfUlaW7oiO4Nr5uNwKUcioFkMVahSk16DQhsyUwEwn8s4C6N1n1c4cg0u92IeCR+zPSy4nTw16Vjq8nJq+mGoEBWmoFBTMc1Sg7FEeboImToUzpH9v1L2CVioKkDmFDd8C/NI+JjNE6J5xdhu9zexol0WKkSjVchxDNz9HfuvZIzw9/MlAMnVkCHCTsqNBl9j8n9hHg0f0XlC9EceYs1Mq2NzLhkqRAsVMJSXRrKJRPmzmMEYZZBeNccacGmbK2tk5gFQAWe4239E5wj4iEgOkVkX5JSf3Afak71q1zJqaG7DEKkAXSRe7XgVraiWkyMi8wzBr+E+063UyBQ8xPYamfbs7aACXkb9BCdABHxEJ4fIKJNPpNrP7RuF47DLRBkn0cAQqQAuPO6y5BnVcvQqIfkTv4csuA+2pKqwg+01s+eaKuDPqJ/GYY+Ej+jkEKXJJZJWvhUSQbspPYn7DJIVJcBhoHI3PHJWtZyROiHep+wJylI1aOOPvl+T7Uuvf5vSDcKfedIFTFou8BzZYvNGwgd/2rXrO7t2iWc+k8jH8c+ejIlzdX6l2jMjBG6eJsCjGCI3gBu6mXk9LecuCx36+CvnVMvJL1EPurWKENENabqdV967CIhJK0LirAu40BZ+zkWIxFUUBR+ROleRdoBqdcrslF2FOYttU3rWxBCZLQwR9ABOl6CysKpajitEtNFGanAR7A3e3G7i0VUKUQ/Ie8sB/J4MsdEi4SM6J0RPfRUreotcdkrVnTun2BGOHzfayHvvnT7a6AGcpqAy2VEtJ1tHvMkbjW7XLwB8D76Im/tq/eaXxoyDFpj73rZgdv+Eha29lKlAelkAITc+efFd++GNiRvg09snigDids33t0j4aFgnRPxbI+2+ZhMd2KG3YfaQtvfLFs1W/9sV9DSRKFM/nKgAXP6p8do4Pl3RNHNjL/2DGrtJfwzwdIvX7V+OXkWc+MRn0Dhw4o463ALHai19upx51+jAvDXXNtpvp5uI6yW9DIcbAgi35SvwFTDvxTOVq1YI9w3GUdij4SO6bojw1yg8Qh4npSrZX+Yg1fwLJCd5tvp087vYyN/VMFoBAbjqDBxtT4hp/rhQJUQvGTea14FqOSm6ZsWtFfdHEo+p6nBq9tFFa+sPYLSJrXvgRcgDEsjpmT2fBwGEHb9owzLel/N17WSFUOKueRStaPiIsxsiYwXgRvI4yXzn0KsPQuLaN2G0yLPdepCbeH/kvvRBmQHayTqs4IdH0wQrWXZ62+XMnqZyOUkLQVkclh9AqHDSIrwM6Un4DUygZ63jsVfPW9kpyEwaHSg0EKvVMQP4HOe9bN18TNENkflPumH6Uv70OTgGYraLopUeQHqp0MhPwT1imhRMZfIuB/CpA29//FWgyyMfgYNQypvLcM2bkF/KKylHioWG0XltoZi4up2xEJZrMPY5T4918zHPa122O4v8CN+tC+MnsAgT5lae7RHh4sfYLixjGRVtyeJpwhxY3QaP4VsOzBIiN8W4z7rR2hIO+skcHMmvlEu5es7dJtlpK2WlGq2MNfcUlKjFPgw53JZg6+eTaABKreMeD1Xvhf2wT8wWR+KUKIpS5CW8xPUKT1NbehZa7ja37VuOWaXmdIdywCO1Xsp2YCd84nk4fmisfOqB2ed7LR5L3/4AZBet7OLDN8PvqM2O9EJZAq6fT6LBb6qlnR4PVbdf0YTjD/JssxXRrtmlqB2HZFF7p03TNBf/8KO28Ppz33JEpO3VaGV/jwv3OAez+F0bS8p+EJZ4SyTjb2OWw8VIyGQSfUquR1a734qMKjzRreGh4ZEmn7CEx4dGiu/00PBogI9HQ+Nh+b6nPsxVI54twb8Ahjkurrlnyq5KdKZejY5ro5ni2hG7N3phkY2vPRYZlUw0b8n14a3NT8Y0d01+SopplH7Q0jlRPOnj8dD2ndVs9n3IzQE/tBHoo+hrSIf60H70mwvbjMBmBDYjsL4I/N9HYeIUbH2D97tXaKmje2Lygaq7RbK1PTssydGrCHlirz7AlhlWOimtIegFhwQQlVMoCQpwk0ucyCsaB8tdCCudlKYtv9yRmtyVdwF+6667bX6v43YMrI0vl8NJJ6UVhHz4/RXAaUvq2KuwPLFXHWDrQqSO3WXYL3O7dZVxU1sdomRT1WsA/Wl80ZvdJ+sweJoqZSEYNbV+0bPA+9sKHaOQPHjQg1qdbgHM0Nt2b1IpC1n0EkKeiHzZ91U6Rr3qHW6A6/ehYqAOpaZviiplIUktQskT6SWyGyj0KGIcWYzlG3ugHCidBHx7MD3pm5VLWSi3ZVCA59Ivyo0ueSKgUsYFlFR8Qnsndx3UmpA6wkNF/wRVikoMUTh5It20ejpG6cIZohDZUke4Hvw6OhZKBsgFcaOBkCf6+0iB/imKUm0do1fFl61LyEGusNTxbkABrl9HJxSVfrlgoozqD9Yv+vu415qvgVEUQJ+KT6+6kYNss9QRZWXz5QAdHSsqA+SC9IXN8sSAPu7FXnJi5u+2jtGn4kMB4pAkljqOLI/vx3+78unoWFGJMi+vXJA2idAv+vu4133T+fP/toE+FV/SciMH3k5VaYoqHV2AvK/7AKLq41uyT8XH8kQfbGAdmQZNTaGjC5L3dR9jFX38K/Wp+IbnMZYXU7KoUOjoguR9XY2iog+zSplXxTdEhyG8DpRzX1gKeaS2Bmk3yGtghrtpUA9m/wv1lOW/jfa33AAAAABJRU5ErkJggg==\n", + "text/latex": [ + "$$\\frac{\\left(2 u_{max} - 3 u_{star}\\right) \\left(2 u_{max} - 3 u_{star} + \\sqrt{- u_{star} \\left(4 u_{max} - 9 u_{star}\\right)}\\right)}{2 \\rho_{max} u_{max} \\left(u_{max} - 2 u_{star}\\right)}$$" + ], + "text/plain": [ + " ⎛ ___________________________⎞\n", + "(2⋅uₘₐₓ - 3⋅uₛₜₐᵣ)⋅⎝2⋅uₘₐₓ - 3⋅uₛₜₐᵣ + ╲╱ -uₛₜₐᵣ⋅(4⋅uₘₐₓ - 9⋅uₛₜₐᵣ) ⎠\n", + "─────────────────────────────────────────────────────────────────────\n", + " 2⋅ρₘₐₓ⋅uₘₐₓ⋅(uₘₐₓ - 2⋅uₛₜₐᵣ) " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_sol[1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating the new flux equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Quadratic equations, of course, have two solutions. Here we have to select the positive root, otherwise our model would have an inconsistency. Are you able to see why? To determine its value, we need to fill in some actual numbers into the model.\n", + "\n", + "Let's start with the same numerical values that we used in [lesson 1](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_01_conservationLaw.ipynb) for $\\rho_{\\rm max}$ and $u_{\\rm max}$. But we also have to supply a value for $u^{\\star}$, a quantity that should be experimentally observed in a given road. We propose $u^{\\star} = 0.7\\, u_{\\rm max}$ for this exercise. This would correspond to 84 km/h for a highway with a 120-km/h speed limit, for example.\n", + "\n", + "Let's numerically evaluate the solutions for $A$ using the following values:\n", + "\n", + "$$\n", + "\\begin{align} \n", + "\\rho_{\\rm max} &=10.0 \\nonumber\\\\ u_{\\rm max} &=1.0 \\nonumber\\\\ u^{\\star} &=0.7 \\nonumber\n", + "\\end{align}\n", + "$$\n", + "\n", + "Now evaluate the numeric result for each root of $A$ using the `evalf()` function, where you pass the numeric substitution as an argument. It's very cool. Let's evaluate both roots and we will pick the positive one.\n", + "\n", + "Let's try the `[0]`-th solution for $A$, first:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMMAAAAPBAMAAACre2ZWAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEM3dMpmJZlQi77urRHZNUE1LAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACsElEQVQ4EbVUTWsTURQ9k2SmSZPWoaKLImQWIi78CAqi2MWA1G2jaEGtEKSmm9Jk5aKLOv+g2XShm1ZxoSsruLIuZmEpdKH5BbYUuxBETfzAYjWed+/MOAW3Psi599xz3zvz5r0JEA1r/I5v0jgCF1br9ZopRePA1CRyI+P1OhZuPI9q1vh0C8pPuKMBBODMTKqucrxAJrDOmVxj/gFwt9frhTCZwlHsb/WxtmuFaLS1ONwsPIHyp73vgIB1HJdTcuyAWeCWIRIPTXSAa0AJkgn0LcHxbD5zWHLRv6TKOrAK5UdeUxMoVrGSkhOLl8C8S6ZxkBY1gPs1mUCRO+o4gOP3V1D6qsUu0IDykH0Q2KBXSjZExi6wETDTKAtjYDNlsS/EwA82vEWmE1tYP4FPvvKQmlq8MJl5LJWFEaxvtNhMoloUtVN9ylUM/GZhmT9kuTfT85C7aCtfm7sCCHQvbrOWls0UFHhWY7UkqsUUBckMLNaQY5PTNO0bbDXFBnDSFMifYbEtYHWbeLxXNlNQ4C7EQqMsbH2m8NeiKhZlaR+JlMxmvhEwNxzFioDVc3HdlYkqD5024/C/XtSgxymJRfSitliDXY2VuXcNP+Kwd4y0gy+88G2dqDLLZuzyRgVJlIWzy+SJBY87z+M+zxq2DYgCvHGFlzw4vwRwihbNtGy6OVZYZ3MUZXo5JE8sisvo4yXhoyBfxb3E4pjyfg92RwD8WOJdAJTjwU+On6R8eoyy8FjyOgzlp2d7yPGsMAq8157ZVo5vx3Cb18wTwBjPIi3HFtnAeoSyB4lqMb/HAmcx7CNPi8KZ+kRF19hyh5rKC1XMtgRQqlnRjRI5doA188FHNtRor3fXgPsBT89kSg9+fMXlOTnDP6qKFp2rN2O+MH2Jf4gGcHvCT8mJxf9L/gB+Rya7CAi8xQAAAABJRU5ErkJggg==\n", + "text/latex": [ + "$$-0.0171107219255619$$" + ], + "text/plain": [ + "-0.0171107219255619" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_val_0 = A_sol[0].evalf(subs={u_star: 0.7, u_max: 1.0, rho_max: 10.0})\n", + "A_val_0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's try the `[1]`-th solution for $A$:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAALQAAAAPBAMAAAC/7vi3AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJZjLNVN0i77urRHZ72Yd1AAAACXBIWXMAAA7EAAAOxAGVKw4bAAACnUlEQVQ4EbVTTWsTURQ900zSpPmkBZEiJqSgCEqDad0oVdCVmw66cdcIFRcRG3QnQl0pomAQF9JNI6ioXRhcCXUR6wcKxfYfWHUlSG3V+l3Hc++dMAHXBnLvO/e8c+a+O2+A3qFhyK+dZX2I//I7T5aAM7Dfw5G5crmUKM4GNfSWXwKKY2+iW6GhQ6M0jmNjXRwsn8nJ+hKwYbGrAgiM1ZyLGPV9v7UJkXWyLDo3MVWH4h7fL0FDqDHabSBCD2h25hbEOjMDPECyafAgsAvbgBQeA/egxVQDqYLh2J73fLyEUGN0soXuVZaD/FGsr1WR/sEMCHwETOZKwDDuAAueFrMVRFYMp2SfhlBjdLaF9DeSQVbrUhXJhijU+jfwugaklzCRa1vnm8isGQ6tQ43R+QLSf2gSZLF261Vkj43sMGvnE62XeCxC4Ap57ulh1zJ24tSBtx40hBqjp0uIfuaeIIv1ZlSRH0cPWyVMkB0rAUPilJatLHIasS+Gk7nEOjSEGqOnC4G1ZbEuifUqum6YNbumtbMi1vEWg+w5idMyRsV4yBVDqDH634F0e7TOnoPLE9MlGEimIvqiBLF2lw+vtTEG61wO1kON0Xx93cFrlExZH2gdr8DlicWFr3GyhniT8kyBQYu8FLxXgp8Dexc1dGiUTjbh6uWzTK+z8/M/X6Ua7a4xC4zmkG/R9BQSbFCex6vcMnybDec0dGiU5qfSVQFPaNlkM4hy1g1z4SezheMuANECMmbt3sVY3TDr56Eh1BiNC+j3nK/Q3O7oF/AE/TWD8ZpzizOh+np55wtoMXPUGQ/wVdBIQ6gxGn3Lz4DLsLz9/ol9wG7/KSJFlhU6Ix88YIoPmvD970FxZ3ExwImBOd5QCR0apdnFf/r9BVU+FzByKuG2AAAAAElFTkSuQmCC\n", + "text/latex": [ + "$$0.0146107219255619$$" + ], + "text/plain": [ + "0.0146107219255619" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_val_1 = A_sol[1].evalf(subs={u_star: 0.7, u_max: 1.0, rho_max: 10.0})\n", + "A_val_1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Because Sympy seems not to return the roots in a deterministic order and we want to use the positive root, we will automatically pick this one by using the Python built-in `max` function." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAALQAAAAPBAMAAAC/7vi3AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJZjLNVN0i77urRHZ72Yd1AAAACXBIWXMAAA7EAAAOxAGVKw4bAAACnUlEQVQ4EbVTTWsTURQ900zSpPmkBZEiJqSgCEqDad0oVdCVmw66cdcIFRcRG3QnQl0pomAQF9JNI6ioXRhcCXUR6wcKxfYfWHUlSG3V+l3Hc++dMAHXBnLvO/e8c+a+O2+A3qFhyK+dZX2I//I7T5aAM7Dfw5G5crmUKM4GNfSWXwKKY2+iW6GhQ6M0jmNjXRwsn8nJ+hKwYbGrAgiM1ZyLGPV9v7UJkXWyLDo3MVWH4h7fL0FDqDHabSBCD2h25hbEOjMDPECyafAgsAvbgBQeA/egxVQDqYLh2J73fLyEUGN0soXuVZaD/FGsr1WR/sEMCHwETOZKwDDuAAueFrMVRFYMp2SfhlBjdLaF9DeSQVbrUhXJhijU+jfwugaklzCRa1vnm8isGQ6tQ43R+QLSf2gSZLF261Vkj43sMGvnE62XeCxC4Ap57ulh1zJ24tSBtx40hBqjp0uIfuaeIIv1ZlSRH0cPWyVMkB0rAUPilJatLHIasS+Gk7nEOjSEGqOnC4G1ZbEuifUqum6YNbumtbMi1vEWg+w5idMyRsV4yBVDqDH634F0e7TOnoPLE9MlGEimIvqiBLF2lw+vtTEG61wO1kON0Xx93cFrlExZH2gdr8DlicWFr3GyhniT8kyBQYu8FLxXgp8Dexc1dGiUTjbh6uWzTK+z8/M/X6Ua7a4xC4zmkG/R9BQSbFCex6vcMnybDec0dGiU5qfSVQFPaNlkM4hy1g1z4SezheMuANECMmbt3sVY3TDr56Eh1BiNC+j3nK/Q3O7oF/AE/TWD8ZpzizOh+np55wtoMXPUGQ/wVdBIQ6gxGn3Lz4DLsLz9/ol9wG7/KSJFlhU6Ix88YIoPmvD970FxZ3ExwImBOd5QCR0apdnFf/r9BVU+FzByKuG2AAAAAElFTkSuQmCC\n", + "text/latex": [ + "$$0.0146107219255619$$" + ], + "text/plain": [ + "0.0146107219255619" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_val = max(A_val_0, A_val_1)\n", + "A_val" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, numerically evaluate $B$ in the same way using the positive root `A_val`:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAL8AAAAPBAMAAABHDgNAAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJZjLNVN0i77urRHZ72Yd1AAAACXBIWXMAAA7EAAAOxAGVKw4bAAADJklEQVQ4EbWUz2tUVxTHPy/zKzOZmbzqJrhIBgOWYsTBiW4iOmBWImawmy4KTqDQRUt5oisRlBZaRMFBRdCNEfxBDOK4EBQFh2CVgtZZldJFkyoIQolRo5Gk9fV7z5tm5h/wwvse7vfc7/nee+57D1YNb8YNiwb9zzZA8q/Ep6RLIwHe3Kam0qVf4OT6m/DFdKlUNNIb3FEhcXywVJJ+jysi6NA4Br6mr7YSbVIgG5AJwyInSS3QBQ/xLnKu5jXY3mQsDMOGkcnAO0pc039U4JgrImhr4KAP8QliVaUsGqTKpKskt76AlwHvOQBnyE6QLWR9MhN8BtmI3Alb6NL2GpCfUhEHbY03/UQGPQ1Sr5SzaBCr4x1RDY0/mt47RqCP3iqx+YzotxRhc0TehcN+DGIVOP2N1jtoa2Qmg94GuUXlLBrklv1YOTLAtWjmBsMM1Mm/Tb5yBpCbjUh1ZibQ/E89RWdgsKKJDAYK5D4oZzGaPFkYVhdGn2pf9BXJhjvKZHSCfzXvttMqLdJ7LYNZkXV1uCYDg7YmMjhfJPFGiyxGk1g4rpb5aRU89b0Ouf2dr/6QXNCymaJA/o5MS7dXc52XfmRg0Na0DAotAxfP2+TQ70tNleCWntg1Uo9PXIPv2O86eVyPN6/WiUzrBM5gQFzRGRh0aOwOoq50tije4OUFadhYE1z1d5Ff8onPfa72dxVE5avgyE9aLXouv4oMDJRf0fx/yanWJacWdcmpxUyNxCIP1IXmWbgXTGqfgWRZtf+p03fXwUhd8mFljsFqZGBAp8a9RT114nZxLtrEnfg+l3UCP/S5t29etcviknIvOP1Aw7qULd+BMR9PPocePVr61YBOjTOIT9BVldyigU7AbQrwI1NwoqbN9tTik+ytuT/BC51HOSP1oa2DhDqlobUGbU10yfzEmoo+J4sGuXHis/riVXOU1Ad+89lNftz7ivQPpaEjakuBiOwOvEvqf2Sw7AwEbU3LYPXcz/ZyWDT4cnCD/lmD0z65teubJKbdz27T2iZJ/XZkcC7Qth3pbfu7opVXXOmR8H4EHZqh69+WXe6jjv8AAqo8T5LfskEAAAAASUVORK5CYII=\n", + "text/latex": [ + "$$0.00853892780744381$$" + ], + "text/plain": [ + "0.00853892780744381" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "B_val = B_sol.evalf(subs={rho_max: 10.0, A: A_val})\n", + "B_val" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Turn off $\\LaTeX$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$\\LaTeX$ output is great when we're looking at algebraic expressions, but it's a little too much for simple numeric output. Let's turn it off for the rest of the exercise:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "sympy.init_printing(use_latex=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Green light: take 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's re-examine the green-light problem from [lesson 1](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_01_conservationLaw.ipynb) but using our newly computed traffic-flux equation. We shouldn't have to change much—in fact, we can simply create a new `flux` function and leave the rest of the code unchanged.\n", + "\n", + "There's one last bit of housekeeping to do so we don't run into trouble -- we used the variables `rho_max` and `u_max` in our SymPy code and we defined them as SymPy `symbols`. You can check on the status of a variable using `type()`. " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n" + ] + } + ], + "source": [ + "print(type(rho_max), type(u_max))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we try to use SymPy variables with NumPy arrays, Python is going to be very unhappy. We can re-define them as floats and avoid that messy situation. " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "rho_max = 10.0\n", + "u_max = 1.0" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def flux(rho, u_max, A, B):\n", + " \"\"\"\n", + " Computes the traffic flux for the better model.\n", + " \n", + " Parameters\n", + " ----------\n", + " rho : numpy.ndarray\n", + " Traffic density along the road as a 1D array of floats.\n", + " u_max : float\n", + " Maximum speed allowed on the road.\n", + " A : float\n", + " Scaling coefficient for rho.\n", + " B : float\n", + " Scaling coefficient for rho squared.\n", + " \n", + " Returns\n", + " -------\n", + " F : numpy.ndarray\n", + " The traffic flux along the road as a 1D array of floats.\n", + " \"\"\"\n", + " F = rho * u_max * (1.0 - A * rho - B * rho**2)\n", + " return F" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def rho_green_light(x, rho_light):\n", + " \"\"\"\n", + " Computes the \"green light\" initial condition.\n", + " It consists of a shock with a linear distribution behind it.\n", + " \n", + " Parameters\n", + " ----------\n", + " x : numpy.ndarray\n", + " Locations on the road as a 1D array of floats.\n", + " rho_light : float\n", + " Car density at the stoplight.\n", + " \n", + " Returns\n", + " -------\n", + " rho : numpy.ndarray\n", + " The initial car density along the road\n", + " as a 1D array of floats.\n", + " \"\"\"\n", + " rho = numpy.zeros_like(x)\n", + " mask = numpy.where(x < 2.0)\n", + " rho[mask] = rho_light * x[mask] / 2.0\n", + " return rho" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "nx = 81 # number of locations on the road\n", + "L = 4.0 # length of the road\n", + "dx = L / (nx - 1) # distance between two consecutive locations\n", + "nt = 30 # number of time steps to compute\n", + "rho_light = 5.0 # car density at the traffic light.\n", + "\n", + "# Define the locations on the road.\n", + "x = numpy.linspace(0.0, L, num=nx)\n", + "\n", + "# Compute the initial traffic density.\n", + "rho0 = rho_green_light(x, rho_light)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the initial car density on the road.\n", + "fig = pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel(r'$x$')\n", + "pyplot.ylabel(r'$\\rho$')\n", + "pyplot.grid()\n", + "line = pyplot.plot(x, rho0,\n", + " color='C0', linestyle='-', linewidth=2)[0]\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(-0.5, 6.0)\n", + "pyplot.tight_layout();" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "def ftbs(rho0, nt, dt, dx, bc_value, *args):\n", + " \"\"\"\n", + " Computes the traffic density on the road \n", + " at a certain time given the initial traffic density.\n", + " \n", + " Parameters\n", + " ----------\n", + " rho0 : numpy.ndarray\n", + " The initial car density along the road\n", + " as a 1D array of floats.\n", + " nt : integer\n", + " The number of time steps to compute.\n", + " dt : float\n", + " The time-step size to integrate.\n", + " dx : float\n", + " The distance between two consecutive locations.\n", + " bc_value : float\n", + " The constant density at the first station.\n", + " args : list or tuple\n", + " Positional arguments to be passed to the flux function.\n", + " \n", + " Returns\n", + " -------\n", + " rho_hist : list of numpy.ndarray objects\n", + " The history of the car density along the road.\n", + " \"\"\"\n", + " rho_hist = [rho0.copy()]\n", + " rho = rho0.copy()\n", + " for n in range(nt):\n", + " # Compute the flux.\n", + " F = flux(rho, *args)\n", + " # Advance in time.\n", + " rho[1:] = rho[1:] - dt / dx * (F[1:] - F[:-1])\n", + " # Set the left boundary condition.\n", + " rho[0] = bc_value\n", + " # Record the time-step solution.\n", + " rho_hist.append(rho.copy())\n", + " return rho_hist" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "# Set time-step size based on CFL limit.\n", + "sigma = 1.0\n", + "dt = sigma * dx / u_max # time-step size\n", + "\n", + "# Compute the traffic density at all time steps.\n", + "rho_hist = ftbs(rho0, nt, dt, dx, rho0[0], u_max, A_val, B_val)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have computed the history of the car density along the road, let's create an animation to visualize the results." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import animation\n", + "from IPython.display import HTML" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "def update_plot(n, rho_hist):\n", + " \"\"\"\n", + " Update the line y-data of the Matplotlib figure.\n", + " \n", + " Parameters\n", + " ----------\n", + " n : integer\n", + " The time-step index.\n", + " rho_hist : list of numpy.ndarray objects\n", + " The history of the numerical solution.\n", + " \"\"\"\n", + " fig.suptitle('Time step {:0>2}'.format(n))\n", + " line.set_ydata(rho_hist[n])" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create an animation of the traffic density.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(rho_hist,),\n", + " interval=100)\n", + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That definitely looks different! Do you think this is more or less accurate than our previous model?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Dig Deeper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The new traffic-flux model that we developed here changes the way that traffic patterns evolve. In this lesson, we only experimented with the most basic scheme: forward-time, backward-space. Try to implement the green-light problem using one of the second-order schemes from [Lesson 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_02_convectionSchemes.ipynb)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Neville D. Fowkes and John J. Mahony, *\"An Introduction to Mathematical Modelling,\"* Wiley & Sons, 1994. Chapter 14: Traffic Flow." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/03_wave/03_04_MUSCL.ipynb b/2-finite-difference-method/lessons/03_wave/03_04_MUSCL.ipynb new file mode 100644 index 0000000..5495774 --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/03_04_MUSCL.ipynb @@ -0,0 +1,1639 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth, I. Hawke. Partly based on [HyperPython](http://nbviewer.ipython.org/github/ketch/HyperPython/tree/master/) by D.I. Ketcheson, also under CC-BY." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Riding the wave" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is the fourth and final lesson of Module 3, _Riding the wave: convection problems_, of the course **\"Practical Numerical Methods with Python\"** (a.k.a., [#numericalmooc](https://twitter.com/hashtag/numericalmooc)). We learned about conservation laws and the traffic-flow model in the [first lesson](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_01_conservationLaw.ipynb), and then about better numerical schemes for convection in [lesson 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_02_convectionSchemes.ipynb). \n", + "\n", + "By then, you should have started to recognize that both mathematical models and numerical schemes work together to give us a good solution to a problem. To drive the point home, [lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_03_aBetterModel.ipynb) deals only with an improved model—and showed you some impressive SymPy tricks!\n", + "\n", + "In this lesson, we'll learn about a new class of discretization schemes, known as finite-volume methods. They are the _most widely used_ methods in computational fluid dynamics, and for good reasons! Let's get started ..." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Finite-volume method" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Are you curious to find out why the finite-volume method (FVM) is the _most popular method_ in computational fluid dynamics? In fact, almost all of the commercial CFD software packages are based on the finite-volume discretization. Here are some reasons:\n", + "\n", + "* FVM discretizations are very general and have no requirement that the grid be structured, like in the finite-difference method. This makes FVM very _flexible_.\n", + "\n", + "* FVM gives a _conservative discretization_ automatically by using directly the conservation laws in integral form." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Conservative discretization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's go right back to the start of this module, where we explained conservation laws looking at a tiny control volume. To simplify the discussion, we just looked at flow in one dimension, with velocity $u$. Imagining a tiny cylindrical volume, like the one shown in Figure 1, there is flux on the left face and right face and we easily explained conservation of mass in that case." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![1Dcontrolvolume](./figures/1Dcontrolvolume.png)\n", + "#### Figure 1. Tiny control volume in the shape of a cylinder." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The law of conservation of mass says that the rate of change of mass in the control volume, plus the net rate of flow of mass across the control surfaces must be zero. The same idea works for other conserved quantities.\n", + "\n", + "Conservation means that any change in the quantity within a volume is due to the amount of that quantity that crosses the boundary. Sounds simple enough. (Remember that we are ignoring possible internal sources of the quantity.) The amount crossing the boundary is the flux. A general conservation law for a quantity $e$ is thus:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial}{\\partial t}\\int_{\\text{cv}}e \\, dV + \\oint_{\\text{cs}}\\vec{F}\\cdot d\\vec{A} =0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $\\vec{F}$ is the flux, and $\\text{cv}$ denotes the control volume with control surface $\\text{cs}$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Why not make the control volume itself our computational cell?**\n", + "\n", + "Imagine that the one-dimensional domain of interest is divided using grid points $x_i$. But instead of trying to compute local values at the grid points, like we did before, we now want to follow the time evolution of _average_ values within each one-dimensional cell of width $\\Delta x$ with center at $x_i$ (the idea is that as long as the cells are small enough, the average values will be a good representation of the quantities we are interested in). \n", + "\n", + "Define $e_i$ as the integral average across the little control volume on the cell with center at $x_i$ (see Figure 2).\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "e_i = \\frac{1}{\\Delta x} \\int_{x_i - \\Delta x / 2}^{x_i + \\Delta x / 2} e(x, t) \\, dx.\n", + "\\end{equation}\n", + "$$\n", + "\n", + "If we know the flux terms at the boundaries of the control volume, which are at $x_{i-1/2}$ and $x_{i+1/2}$, the general conservation law for this small control volume gives:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial}{\\partial t} e_i + \\frac{1}{\\Delta x} \\left[ F \\left( x_{i+1/2}, t \\right) - F \\left( x_{i - 1 / 2}, t \\right) \\right] = 0.\n", + "\\end{equation}\n", + "$$ \n", + "\n", + "This now just requires a time-stepping scheme, and is easy to solve *if* we can find $F$ on the control surfaces." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![finite volume](./figures/finite_volume.png)\n", + "\n", + "#### Figure 2. Discretizing a 1D domain into finite volumes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We've seen with the traffic model that the flux can depend on the conserved quantity (in that case, the traffic density). That is generally the case, so we write that $F = F(e)$. We will need to compute, or approximate, the flux terms at the cell edges (control surfaces) from the integral averages, $e_i$.\n", + "\n", + "If we had a simple convection equation with $c>0$, then the flux going into the cell centered at $x_i$ from the left would be $F(e_{i-1})$ and the flux going out the cell on the right side would be $F(e_{i})$ (see Figure 2). Applying these fluxes in Equation (3) results in a scheme that is equivalent to our tried-and-tested backward-space (upwind) scheme! \n", + "\n", + "We know from previous lessons that the backward-space scheme is first order and the error introduces numerical diffusion. Also, remember what happened when we tried to use it with the non-linear [traffic model](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_01_conservationLaw.ipynb) in the green-light problem? *It blew up!* That was because the problem contains both right-moving and left-moving waves (if you don't remember that discussion, go back and review it; it's important!).\n", + "\n", + "To skirt this difficulty in the green-light problem, we chose initial conditions that don't produce negative wave speeds. But that's cheating! A genuine solution would be to have a scheme that can deal with both positive and negative wave speeds. Here is where Godunov comes in." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Godunov's method" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Godunov proposed a first-order method in 1959 that uses the integral form of the conservation laws, Equation (1), and a piecewise constant representation of the solution, as shown in Figure (2). Notice that representing the solution in this way is like having a myriad of little shocks at the cell boundaries (control surfaces).\n", + "\n", + "For each control surface, we have *two values* for the solution $e$ at a given time: the constant value to the left, $e_L$, and the constant value to the right, $e_R$. A situation where you have a conservation law with a constant initial condition, except for a single jump discontinuity is called a **Riemann problem**. \n", + "\n", + "The Riemann problem has an exact solution for the Euler equations (as well as for any scalar conservation law). The [shock-tube problem](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_05_Sods_Shock_Tube.ipynb), subject of your assignment for this course module, is a Riemann problem! And because it has an analytical solution, we can use it for testing the accuracy of numerical methods. \n", + "\n", + "But Godunov had a better idea. With the solution represented as piecewise constant (Figure 2), why not use the analytical solution of the Riemann problem at each cell boundary? Solving a Riemann problem gives all the information about the characteristic structure of the solution, including the sign of the wave speed. The full solution can then be reconstructed from the union of all the Riemann solutions at cell boundaries. *Neat idea, Godunov!*\n", + "\n", + "Figure 3 illustrates a Riemann problem for the Euler equations, associated to the shock tube. The space-time plot shows the characteristic lines for the left-traveling expansion wave, and the right-traveling contact discontinuity and shock." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Riemann-shocktube](./figures/Riemann-shocktube.png)\n", + "\n", + "#### Figure 3. The shock tube: a Riemann problem for Euler's equations. Physical space (top) and $x, t$ space (bottom)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to solve many Riemann problems from $t$ to $t + \\Delta t$, one on each cell boundary (illustrated in Figure 4). The numerical flux on $x_{i+1/2}$ is \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "F_{i+1/2}= \\frac{1}{\\Delta t} \\int_{t^n}^{t^{n+1}} F\\left(e(x_{i+1/2},t) \\right)\\,dt\n", + "\\end{equation}\n", + "$$\n", + "\n", + "To be able to solve each Riemann problem independently, they should not interact, which imposes a limit on $\\Delta t$. Looking at Figure 4, you might conclude that we must require a CFL number of 1/2 to avoid interactions between the Riemann solutions, but the numerical flux above only depends on the state at $x_{i+1/2}$, so we're fine as long as the solution there is not affected by that at $x_{i-1/2}$—i.e., the CFL limit is really 1." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![many_Rieman_problems](./figures/many_Rieman_problems.png)\n", + "\n", + "#### Figure 4. Riemann problems on each cell boundary." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Riemann solution, even though known analytically, can get quite hairy for non-linear systems of conservation laws (like the Euler equations). And we need as many Riemann solutions as there are finite-volume cell boundaries, and again at each time step! This gets really cumbersome. \n", + "\n", + "Godunov solved the Riemann problems exactly, but many after him proposed *approximate* Riemann solutions instead. We'll be calculating the full solution numerically, after all, so some controlled approximations can be made. You might imagine a simple approximation for the flux at a cell boundary that is just the average between the left and right values, for example: $\\frac{1}{2}\\left[F(e_L)+F(e_R)\\right]$. But that leads to a central scheme and, on its own, is unstable. Adding a term proportional to the difference between left and right states, $e_R-e_L$, supplies artificial dissipation and gives stability (see van Leer et al., 1987).\n", + "\n", + "One formula for the numerical flux at $x_{i+1/2}$ called the Rusanov flux, a.k.a. Lax-Friedrichs flux, is given by\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "F_{i+1/2}= \\frac{1}{2} \\left[ F \\left( e_L \\right) + F \\left( e_R \\right) \\right] - \\frac{1}{2} \\max \\left|F'(e)\\right| \\left( e_R - e_L \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $F'(e)$ is the Jacobian of the flux function and $\\max\\left|F'(e)\\right|$ is the local propagation speed of the fastest traveling wave. The Riemann solutions at each cell boundary do not interact if $\\max|F'(e)|\\leq\\frac{\\Delta x}{\\Delta t}$, which leads to a flux formula we can now use:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "F_{i+1/2}= \\frac{1}{2} \\left( F \\left( e_{i} \\right) + F \\left( e_{i+1} \\right) - \\frac{\\Delta x}{\\Delta t} \\left( e_{i+1} - e_{i} \\right) \\right)\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Let's try it!" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot, animation\n", + "from IPython.display import HTML\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's apply Godunov's method to the [LWR traffic model](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_01_conservationLaw.ipynb). In [lesson 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_02_convectionSchemes.ipynb) we already wrote functions to set the initial conditions for a red-light problem and to compute the fluxes. To save us from writing this out again, we saved those functions into a Python file named `traffic.py` (found in the same directory of the course repository). Now, we can use those functions by importing them in the same way that we import NumPy or any other library. Like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from traffic import rho_red_light, flux" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "You've probably noticed that we have the habit of writing detailed explanations of what a function does after defining it, in comments. These comments are called *docstrings* and it is good practice to include them in all your functions. It can be very useful when loading a function that you aren't familiar with (or don't remember!), because the `help` command will print them out for you. Check it out:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function rho_red_light in module traffic:\n", + "\n", + "rho_red_light(x, rho_max)\n", + " Computes the \"red light\" initial condition with shock.\n", + " \n", + " Parameters\n", + " ----------\n", + " x : numpy.ndarray\n", + " Locations on the road as a 1D array of floats.\n", + " rho_max : float\n", + " The maximum traffic density allowed.\n", + " \n", + " Returns\n", + " -------\n", + " rho : numpy.ndarray\n", + " The initial car density along the road as a 1D array of floats.\n", + "\n" + ] + } + ], + "source": [ + "help(rho_red_light)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can write some code to set up our notebook environment, and set the calculation parameters, with the functions imported above readily available." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "nx = 100 # number of cells along the road\n", + "L = 4.0 # length of the road\n", + "dx = L / nx # cell width\n", + "nt = 30 # number of time steps to compute\n", + "rho_max = 10.0 # maximum traffic density allowed\n", + "u_max = 1.0 # speed limit\n", + "\n", + "# Get the grid-cell centers.\n", + "# x_i is now the center of the i-th cell.\n", + "x = numpy.linspace(0.0 + 0.5 * dx, L - 0.5 * dx, num=nx)\n", + "\n", + "# Compute the initial traffic density.\n", + "rho0 = rho_red_light(x, rho_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the initial car density on the road.\n", + "fig = pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel(r'$x$')\n", + "pyplot.ylabel(r'$\\rho$')\n", + "pyplot.grid()\n", + "line = pyplot.plot(x, rho0,\n", + " color='C0', linestyle='-', linewidth=2)[0]\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(4.0, 11.0)\n", + "pyplot.tight_layout();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below is a new function for applying Godunov's method with Lax-Friedrichs fluxes. Study it carefully." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def godunov(rho0, nt, dt, dx, bc_values, *args):\n", + " \"\"\"\n", + " Computes and returns the history of the traffic density\n", + " on the road using a Godunov scheme\n", + " with a Lax-Friedrichs flux.\n", + " \n", + " Parameters\n", + " ----------\n", + " rho0 : numpy.ndarray\n", + " The initial traffic density along the road\n", + " as a 1D array of floats.\n", + " nt : integer\n", + " The number of time steps to compute.\n", + " dt : float\n", + " The time-step size to integrate.\n", + " dx : float\n", + " The distance between two consecutive locations.\n", + " bc_values : tuple or list\n", + " The value of the density at the first and last locations\n", + " as a tuple or list of two floats.\n", + " args : list\n", + " Positional arguments to be passed to the flux function.\n", + " \n", + " Returns\n", + " -------\n", + " rho_hist : list of numpy.ndarray objects\n", + " The history of the car density along the road\n", + " as a list of 1D arrays of floats.\n", + " \"\"\"\n", + " rho_hist = [rho0.copy()]\n", + " rho = rho0.copy()\n", + " for n in range(nt):\n", + " rhoL = rho[:-1] # i-th value at index i-1/2\n", + " rhoR = rho[1:] # i+1-th value at index i-1/2\n", + " # Compute the flux at cell boundaries.\n", + " F = 0.5 * (flux(rhoL, *args) + flux(rhoR, *args) -\n", + " dx / dt * (rhoR - rhoL))\n", + " # Advance in time.\n", + " rho[1:-1] = rho[1:-1] - dt / dx * (F[1:] - F[:-1])\n", + " # Apply boundary conditions.\n", + " rho[0], rho[-1] = bc_values\n", + " # Record the time-step solution.\n", + " rho_hist.append(rho.copy())\n", + " return rho_hist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can run using a CFL of $1$, to start with, but you should experiment with different values." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Set time-step size based on CFL limit.\n", + "sigma = 1.0\n", + "dt = sigma * dx / u_max # time-step size\n", + "\n", + "# Compute the traffic density at all time steps.\n", + "rho_hist = godunov(rho0, nt, dt, dx, (rho0[0], rho0[-1]),\n", + " u_max, rho_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def update_plot(n, rho_hist):\n", + " \"\"\"\n", + " Update the line y-data of the Matplotlib figure.\n", + " \n", + " Parameters\n", + " ----------\n", + " n : integer\n", + " The time-step index.\n", + " rho_hist : list of numpy.ndarray objects\n", + " The history of the numerical solution.\n", + " \"\"\"\n", + " fig.suptitle('Time step {:0>2}'.format(n))\n", + " line.set_ydata(rho_hist[n])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create an animation of the traffic density.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(rho_hist,),\n", + " interval=100)\n", + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You'll see that the result is very similar to the original Lax-Friedrichs method, and with good reason: they're essentially the same! But this is only because we are using a uniform grid. In the finite-volume approach, using the integral form of the equations, we were free to use a spatially varying grid spacing, if we wanted to. \n", + "\n", + "The original Godunov method is first-order accurate, due to representing the conserved quantity by a piecewise-constant approximation. That is why you see considerable numerical diffusion in the solution. But Godunov's method laid the foundation for all finite-volume methods to follow and it was a milestone in numerical solutions of hyperbolic conservation laws. A whole industry developed inventing \"high-resolution\" methods that offer second-order accuracy and higher." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Dig deeper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Godunov's method works in problems having waves moving with positive or negative wave speeds. Try it on the green-light problem introduced in [lesson 1](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_01_conservationLaw.ipynb) using the initial condition containing waves traveling in both directions.\n", + "\n", + "* Investigate two or three different numerical flux schemes (you can start with van Leer et al., 1987, or Google for other references. Implement the different flux schemes and compare!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## MUSCL schemes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Godunov's method is first-order accurate, which we already know is not appropriate for hyperbolic conservation laws, due to the high numerical diffusion. This poses particular difficulty near sharp gradients in the solution.\n", + "\n", + "To do better, we can replace the piecewise constant representation of the solution with a piecewise linear version (still discontinuous at the edges). This leads to the MUSCL scheme (for Monotonic Upstream-Centered Scheme for Conservation Laws), invented by van Leer (1979)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reconstruction in space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The piecewise linear reconstruction consists of representing the solution inside each cell with a *straight line* (see Figure 5). Define the cell representation as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "e(x) = e_i + \\sigma_i (x - x_i).\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $\\sigma_i$ is the *slope* of the approximation within the cell (to be defined), and $e_i$ is the Godunov cell average. The choice $\\sigma_i=0$ gives Godunov's method.\n", + "\n", + "Standard central differencing would give\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\sigma_i = \\frac{e_{i+1} - e_{i-1}}{2 \\Delta x}.\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "#### Figure 5. Piecewise linear approximation of the solution." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But we saw with the results [in the second lesson](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_02_convectionSchemes.ipynb) that this can lead to oscillations near shocks. These [Gibbs oscillations](http://en.wikipedia.org/wiki/Gibbs_phenomenon) will always appear (according to [Godunov's theorem](http://en.wikipedia.org/wiki/Godunov's_theorem)) unless we use constant reconstruction. So we have to modify, or *limit* the slope, near shocks.\n", + "\n", + "The easiest way to limit is to compute one-sided slopes\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\Delta e^- = \\frac{e_i - e_{i-1}}{\\Delta x}, \\quad \\Delta e^+ = \\frac{e_{i+1} - e_{i}}{\\Delta x}, \n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Figure 6. One-sided slopes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now build the *minmod* slope\n", + "\n", + "$$\n", + "\\begin{align}\n", + " \\sigma_i & = \\text{minmod}(\\Delta e^-, \\Delta e^+) \\\\\n", + " & = \\begin{cases} \\min(\\Delta e^-, \\Delta e^+) & \\text{ if } \\Delta e^-, \\Delta e^+ > 0 \\\\\n", + " \\max(\\Delta e^-, \\Delta e^+) & \\text{ if } \\Delta e^-, \\Delta e^+ < 0 \\\\\n", + "0 & \\text{ if } \\Delta e^- \\cdot \\Delta e^+ \\leq 0\n", + " \\end{cases}\n", + "\\end{align}\n", + "$$\n", + "\n", + "That is, use the *smallest* one-sided slope in magnitude, unless the slopes have different sign, in which cases it uses the constant reconstruction (i.e., Godunov's method).\n", + "\n", + "Once the *minmod* slope is calculated, we can use it to obtain the values at the interfaces between cells.\n", + "\n", + "$$\n", + "\\begin{align}\n", + "e^{R}_{i-1/2} &= e_i - \\sigma_i \\frac{\\Delta x}{2}\\\\\n", + "e^{L}_{i+1/2} &= e_i + \\sigma_i \\frac{\\Delta x}{2}\n", + "\\end{align}\n", + "$$\n", + "\n", + "where $e^R$ and $e^L$ are the local interpolated values of the conserved quantity immediately to the right and left of the cell boundary, respectively. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Index headache" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that for the cell with index $i$, we calculate $e^R_{i-1/2}$ and $e^L_{i+1/2}$. Look at Figure 5: those are the two local values of the solution are at opposite cell boundaries.\n", + "\n", + "However, when we calculate the local flux at the cell boundaries, we use the local solution values on either side of that cell boundary. That is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "F_{i+1/2} = f(e^L_{i+1/2}, e^R_{i+1/2})\n", + "\\end{equation}\n", + "$$\n", + "\n", + "You can calculate two flux vectors; one for the right-boundary values and one for the left-boundary values. Be careful that you know which boundary value a given index in these two vectors might refer to!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here is a Python function implementing minmod." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def minmod(e, dx):\n", + " \"\"\"\n", + " Computes the minmod approximation of the slope.\n", + " \n", + " Parameters\n", + " ----------\n", + " e : list or numpy.ndarray\n", + " The input values as a 1D array of floats.\n", + " dx : float\n", + " The grid-cell width.\n", + " \n", + " Returns\n", + " -------\n", + " sigma : numpy.ndarray\n", + " The minmod-approximated slope\n", + " as a 1D array of floats.\n", + " \"\"\"\n", + " sigma = numpy.zeros_like(e)\n", + " for i in range(1, len(e) - 1):\n", + " de_minus = (e[i] - e[i - 1]) / dx\n", + " de_plus = (e[i + 1] - e[i]) / dx\n", + " if de_minus > 0 and de_plus > 0:\n", + " sigma[i] = min(de_minus, de_plus)\n", + " elif de_minus < 0 and de_plus < 0:\n", + " sigma[i] = max(de_minus, de_plus)\n", + " else:\n", + " sigma[i] = 0.0\n", + " return sigma" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evolution in time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since we are aiming for second-order accuracy in space, we might as well try for second-order in time, as well. We need a method to evolve the *ordinary* differential equation forwards in time:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\frac{\\partial}{\\partial t} e_i + \\frac{1}{\\Delta x} \\left[ F \\left( x_{i+1/2}, t \\right) - F \\left( x_{i - 1 / 2}, t \\right) \\right] = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "A second-order Runge-Kutta method with special characteristics (due to Shu & Osher, 1988) gives the following scheme:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "e^*_i & = e^n_i + \\frac{\\Delta t}{\\Delta x}\\left( F^n_{i-1/2} - F^n_{i+1/2} \\right) \\\\\n", + "e^{n+1}_i & = \\frac{1}{2} e^n_i + \\frac{1}{2}\\left( e^*_i + \\frac{\\Delta t}{\\Delta x}\\left( F^*_{i-1/2} - F^*_{i+1/2} \\right) \\right)\n", + "\\end{align}\n", + "$$\n", + "\n", + "Recall that the Rusanov flux is defined as\n", + " \n", + "$$\n", + "F_{i+1/2}= \\frac{1}{2} \\left[ F \\left( e_L \\right) + F \\left( e_R \\right) \\right] - \\frac{1}{2} \\max \\left|F'(e)\\right| \\left( e_R - e_L \\right)\n", + "$$\n", + "\n", + "Armed with the interpolated values of $e$ at the cell boundaries we can generate a more accurate Rusanov flux. At cell boundary $i+1/2$, for example, this is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "F_{i+1/2} = \\frac{1}{2} \\left( F \\left( e^L_{i+1/2} \\right) + F \\left( e^R_{i+1/2} \\right) - \\frac{\\Delta x}{\\Delta t} \\left( e^R_{i+1/2} - e^L_{i+1/2} \\right) \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Now we are ready to try some MUSCL!" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def muscl(rho0, nt, dt, dx, bc_values, *args):\n", + " \"\"\"\n", + " Computes and returns the history of the traffic density\n", + " on the road using a MUSCL scheme with a minmod slope limiting\n", + " and a Lax-Friedrichs flux.\n", + " The function uses a second-order Runge-Kutta method\n", + " to integrate in time.\n", + " \n", + " Parameters\n", + " ----------\n", + " rho0 : numpy.ndarray\n", + " The initial traffic density along the road\n", + " as a 1D array of floats.\n", + " nt : integer\n", + " The number of time steps to compute.\n", + " dt : float\n", + " The time-step size to integrate.\n", + " dx : float\n", + " The distance between two consecutive locations.\n", + " bc_values : tuple or list\n", + " The value of the density at the first and last locations\n", + " as a tuple or list of two floats.\n", + " args : list\n", + " Positional arguments to be passed to the flux function.\n", + " \n", + " Returns\n", + " -------\n", + " rho_hist : list of numpy.ndarray objects\n", + " The history of the car density along the road\n", + " as a list of 1D array of floats.\n", + " \"\"\"\n", + " def compute_flux(rho):\n", + " # Compute the minmod slope.\n", + " sigma = minmod(rho, dx)\n", + " # Reconstruct values at cell boundaries.\n", + " rhoL = (rho + sigma * dx / 2.0)[:-1]\n", + " rhoR = (rho - sigma * dx / 2.0)[1:]\n", + " # Compute the flux.\n", + " F = 0.5 * (flux(rhoL, *args) + flux(rhoR, *args) -\n", + " dx / dt * (rhoR - rhoL))\n", + " return F\n", + " rho_hist = [rho0.copy()]\n", + " rho = rho0.copy()\n", + " rho_star = rho.copy()\n", + " for n in range(nt):\n", + " # Compute the flux at cell boundaries.\n", + " F = compute_flux(rho)\n", + " # Perform 1st step of RK2.\n", + " rho_star[1:-1] = rho[1:-1] - dt / dx * (F[1:] - F[:-1])\n", + " # Apply boundary conditions.\n", + " rho_star[0], rho_star[-1] = bc_values\n", + " # Compute the flux at cell boundaries.\n", + " F = compute_flux(rho_star)\n", + " # Perform 2nd step of RK2.\n", + " rho[1:-1] = 0.5 * (rho[1:-1] + rho_star[1:-1] -\n", + " dt / dx * (F[1:] - F[:-1]))\n", + " # Apply boundary conditions.\n", + " rho[0], rho[-1] = bc_values\n", + " # Record the time-step solution.\n", + " rho_hist.append(rho.copy())\n", + " return rho_hist" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Set time-step size based on CFL limit.\n", + "sigma = 1.0\n", + "dt = sigma * dx / u_max # time-step size\n", + "\n", + "# Compute the traffic density at all time steps.\n", + "rho_hist = muscl(rho0, nt, dt, dx, (rho0[0], rho0[-1]),\n", + " u_max, rho_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create an animation of the traffic density.\n", + "anim = animation.FuncAnimation(fig, update_plot,\n", + " frames=nt, fargs=(rho_hist,),\n", + " interval=100)\n", + "# Display the video.\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This MUSCL scheme does not show any of the oscillations you might see with MacCormack or Lax-Wendroff, but the features are not as sharp. Using the _minmod_ slopes led to some smearing of the shock, which motivated many researchers to investigate other options. Bucketloads of so-called _shock-capturing_ schemes exist and whole books are written on this topic. Some people dedicate their lives to developing numerical methods for hyperbolic equations!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Challenge task" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Go back to Sod! Calculate the shock-tube problem using the MUSCL scheme and compare with your previous results. What do think?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Godunov, S.K. (1959), \"A difference scheme for numerical computation of discontinuous solutions of equations of fluid dynamics,\" _Math. Sbornik_, Vol. 47, pp. 271–306.\n", + "\n", + "* van Leer, Bram (1979), \"Towards the ultimate conservative difference scheme, V. A second-order sequel to Godunov's method,\" _J. Comput. Phys._, Vol. 32, pp. 101–136\n", + "\n", + "* van Leer, B., J.L. Thomas, P.L. Roe, R.W. Newsome (1987). \"A comparison of numerical flux formulas for the Euler and Navier-Stokes equations,\" AIAA paper 87-1104 // [PDF from umich.edu](http://deepblue.lib.umich.edu/bitstream/handle/2027.42/76365/AIAA-1987-1104-891.pdf), checked 11/01/14.\n", + "\n", + "* Shu, Chi-Wang and Osher, Stanley (1988). \"Efficient implementation of essentially non-oscillatory shock-capturing schemes,\" _J. Comput. Phys._, Vol. 77, pp. 439–471 // [PDF from NASA Tech. Report server](http://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/19870013797.pdf)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/03_wave/03_05_Sods_Shock_Tube.ipynb b/2-finite-difference-method/lessons/03_wave/03_05_Sods_Shock_Tube.ipynb new file mode 100644 index 0000000..fcba5a8 --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/03_05_Sods_Shock_Tube.ipynb @@ -0,0 +1,651 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, C.D. Cooper, G.F. Forsyth. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Riding the wave" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sod's test problems" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sod's test problems are standard benchmarks used to assess the accuracy of numerical solvers. The tests use a classic example of one-dimensional compressible flow: the shock-tube problem. Sod (1978) chose initial conditions and numerical discretization parameters for the shock-tube problem and used these to test several schemes, including Lax-Wendroff and MacCormack's. Since then, many others have followed Sod's example and used the same tests on new numerical methods.\n", + "\n", + "The shock-tube problem is so useful for testing numerical methods because it is one of the few problems that allows an exact solution of the Euler equations for compressible flow.\n", + "\n", + "This notebook complements the previous lessons of the course module [_\"Riding the wave: convection problems\"_](https://github.com/numerical-mooc/numerical-mooc/tree/master/lessons/03_wave) with Sod's test problems as an independent coding exercise. We'll lay out the problem for you, but leave important bits of code for you to write on your own. Good luck!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### What's a shock tube?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A shock tube is an idealized device that generates a one-dimensional shock wave in a compressible gas. The setting allows an analytical solution of the Euler equations, which is very useful for comparing with the numerical results to assess their accuracy. \n", + "\n", + "Picture a tube with two regions containing gas at different pressures, separated by an infinitely-thin, rigid diaphragm. The gas is initially at rest, and the left region is at a higher pressure than the region to the right of the diaphragm. At time $t = 0.0 s$, the diaphragm is ruptured instantaneously. \n", + "\n", + "What happens? \n", + "\n", + "You get a shock wave. The gas at high pressure, no longer constrained by the diaphragm, rushes into the lower-pressure area and a one-dimensional unsteady flow is established, consisting of:\n", + "\n", + "* a shock wave traveling to the right\n", + "* an expansion wave traveling to the left\n", + "* a moving contact discontinuity\n", + "\n", + "The shock-tube problem is an example of a *Riemann problem* and it has an analytical solution, as we said. The situation is illustrated in Figure 1." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![shocktube](./figures/shocktube.png)\n", + "#### Figure 1. The shock-tube problem." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The Euler equations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Euler equations govern the motion of an inviscid fluid (no viscosity). They consist of the conservation laws of mass and momentum, and often we also need to work with the energy equation. \n", + "\n", + "Let's consider a 1D flow with velocity $u$ in the $x$-direction. The Euler equations for a fluid with density $\\rho$ and pressure $p$ are:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\frac{\\partial \\rho}{\\partial t} + \\frac{\\partial}{\\partial x}(\\rho u) &= 0 \\\\\n", + "\\frac{\\partial}{\\partial t}(\\rho u) + \\frac{\\partial}{\\partial x} (\\rho u^2 + p)&=0\n", + "\\end{align}\n", + "$$\n", + "\n", + "... plus the energy equation, which we can write in this form:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial}{\\partial t}(\\rho e_T) + \\frac{\\partial}{\\partial x} (\\rho u e_T +p u)=0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $e_T=e+u^2/2$ is the total energy per unit mass, equal to the internal energy plus the kinetic energy (per unit mass).\n", + "\n", + "Written in vector form, you can see that the Euler equations bear a strong resemblance to the traffic-density equation that has been the focus of this course module so far. Here is the vector representation of the Euler equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial }{\\partial t} \\underline{\\mathbf{u}} + \\frac{\\partial }{\\partial x} \\underline{\\mathbf{f}} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The big difference with our previous work is that the variables $\\underline{\\mathbf{u}}$ and $\\underline{\\mathbf{f}}$ are *vectors*. If you review the [Phugoid Full Model](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb) lesson, you will recall that we can solve for several values at once using the vector form of an equation. In the Phugoid Module, it was an ODE—now we apply the same procedure to a PDE. \n", + "\n", + "Let's take a look at what $\\underline{\\mathbf{u}}$ and $\\underline{\\mathbf{f}}$ consist of." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The conservative form" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Many works in the early days of computational fluid dynamics in the 1960s showed that using the conservation form of the Euler equations is more accurate for situations with shock waves. And as you already saw, the shock-tube solutions do contain shocks.\n", + "\n", + "The conserved variables $\\underline{\\mathbf{u}}$ for Euler's equations are\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\underline{\\mathbf{u}} = \\left[\n", + "\\begin{array}{c}\n", + "\\rho \\\\\n", + "\\rho u \\\\\n", + "\\rho e_T \\\\ \n", + "\\end{array}\n", + "\\right]\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $\\rho$ is the density of the fluid, $u$ is the velocity of the fluid and $e_T = e + \\frac{u^2}{2}$ is the specific total energy; $\\underline{\\mathbf{f}}$ is the flux vector:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\underline{\\mathbf{f}} = \\left[\n", + "\\begin{array}{c}\n", + "\\rho u \\\\\n", + "\\rho u^2 + p \\\\\n", + "(\\rho e_T + p) u \\\\\n", + "\\end{array}\n", + "\\right]\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $p$ is the pressure of the fluid.\n", + "\n", + "If we put together the conserved variables and the flux vector into our PDE, we get the following set of equations:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\frac{\\partial}{\\partial t}\n", + " \\left[\n", + " \\begin{array}{c}\n", + " \\rho \\\\\n", + " \\rho u \\\\\n", + " \\rho e_T \\\\\n", + " \\end{array}\n", + " \\right] +\n", + " \\frac{\\partial}{\\partial x}\n", + " \\left[\n", + " \\begin{array}{c}\n", + " \\rho u \\\\\n", + " \\rho u^2 + p \\\\\n", + " (\\rho e_T + p) u \\\\\n", + " \\end{array}\n", + " \\right] =\n", + " 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "There's one major problem there. We have 3 equations and 4 unknowns. But there is a solution! We can use an equation of state to calculate the pressure—in this case, we'll use the ideal gas law." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculating the pressure" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For an ideal gas, the equation of state is\n", + "\n", + "$$\n", + "e = e(\\rho, p) = \\frac{p}{(\\gamma -1) \\rho}\n", + "$$\n", + "\n", + "where $\\gamma = 1.4$ is a reasonable value to model air, \n", + "\n", + "$$\n", + "\\therefore p = (\\gamma -1)\\rho e\n", + "$$ \n", + "\n", + "Recall from above that\n", + "\n", + "$$\n", + "e_T = e+\\frac{1}{2} u^2\n", + "$$\n", + "\n", + "$$\n", + "\\therefore e = e_T - \\frac{1}{2}u^2\n", + "$$\n", + "\n", + "Putting it all together, we arrive at an equation for the pressure\n", + "\n", + "$$\n", + "p = (\\gamma -1)\\left(\\rho e_T - \\frac{\\rho u^2}{2}\\right)\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Flux in terms of $\\underline{\\mathbf{u}}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the traffic model, the flux was a function of traffic density. For the Euler equations, the three equations we have are coupled and the flux *vector* is a function of $\\underline{\\mathbf{u}}$, the vector of conserved variables:\n", + "\n", + "$$\n", + "\\underline{\\mathbf{f}} = f(\\underline{\\mathbf{u}})\n", + "$$\n", + "\n", + "In order to get everything squared away, we need to represent $\\underline{\\mathbf{f}}$ in terms of $\\underline{\\mathbf{u}}$.\n", + "We can introduce a little shorthand for the $\\underline{\\mathbf{u}}$ and $\\underline{\\mathbf{f}}$ vectors and define:\n", + "\n", + "$$\n", + "\\underline{\\mathbf{u}} =\n", + "\\left[\n", + " \\begin{array}{c}\n", + " u_1 \\\\\n", + " u_2 \\\\\n", + " u_3 \\\\\n", + " \\end{array}\n", + "\\right] =\n", + "\\left[\n", + " \\begin{array}{c}\n", + " \\rho \\\\\n", + " \\rho u \\\\\n", + " \\rho e_T \\\\\n", + " \\end{array}\n", + "\\right]\n", + "$$\n", + "\n", + "$$\n", + "\\underline{\\mathbf{f}} =\n", + "\\left[\n", + " \\begin{array}{c}\n", + " f_1 \\\\\n", + " f_2 \\\\\n", + " f_3 \\\\\n", + " \\end{array}\n", + "\\right] =\n", + "\\left[\n", + " \\begin{array}{c}\n", + " \\rho u \\\\\n", + " \\rho u^2 + p \\\\\n", + " (\\rho e_T + p) u \\\\\n", + " \\end{array}\n", + "\\right]\n", + "$$ \n", + "\n", + "With a little algebraic trickery, we can represent the pressure vector using quantities from the $\\underline{\\mathbf{u}}$ vector.\n", + "\n", + "$$\n", + "p = (\\gamma -1)\\left(u_3 - \\frac{1}{2} \\frac{u^2_2}{u_1} \\right)\n", + "$$\n", + "\n", + "Now that pressure can be represented in terms of $\\underline{\\mathbf{u}}$, the rest of $\\underline{\\mathbf{f}}$ isn't too difficult to resolve:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$\\underline{\\mathbf{f}} = \\left[ \\begin{array}{c}\n", + "f_1 \\\\\n", + "f_2 \\\\\n", + "f_3 \\\\ \\end{array} \\right] =\n", + "\\left[ \\begin{array}{c}\n", + "u_2\\\\\n", + "\\frac{u^2_2}{u_1} + (\\gamma -1)\\left(u_3 - \\frac{1}{2} \\frac{u^2_2}{u_1} \\right) \\\\\n", + "\\left(u_3 + (\\gamma -1)\\left(u_3 - \\frac{1}{2} \\frac{u^2_2}{u_1}\\right) \\right) \\frac{u_2}{u_1}\\\\ \\end{array}\n", + "\\right]$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test conditions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first test proposed by Sod in his 1978 paper is as follows. \n", + "\n", + "In a tube spanning from $x = -10 \\text{m}$ to $x = 10 \\text{m}$ with the rigid membrane at $x = 0 \\text{m}$, we have the following initial gas states:\n", + "\n", + "$$\n", + "\\underline{IC}_L =\n", + "\\left[\n", + " \\begin{array}{c}\n", + " \\rho_L \\\\\n", + " u_L \\\\\n", + " p_L \\\\\n", + " \\end{array}\n", + "\\right] =\n", + "\\left[\n", + " \\begin{array}{c}\n", + " 1.0 \\, kg/m^3 \\\\\n", + " 0 \\, m/s \\\\\n", + " 100 \\, kN/m^2 \\\\\n", + " \\end{array}\n", + "\\right]\n", + "$$\n", + "\n", + "$$\n", + "\\underline{IC}_R =\n", + "\\left[\n", + " \\begin{array}{c}\n", + " \\rho_R \\\\\n", + " u_R \\\\\n", + " p_R \\\\\n", + " \\end{array}\n", + "\\right] =\n", + "\\left[\n", + " \\begin{array}{c}\n", + " 0.125 \\, kg/m^3 \\\\\n", + " 0 \\, m/s \\\\\n", + " 10 \\, kN/m^2 \\\\\n", + " \\end{array}\n", + "\\right]\n", + "$$\n", + "\n", + "where $\\underline{IC}_L$ are the initial density, velocity and pressure on the left side of the tube membrane and $\\underline{IC}_R$ are the initial density, velocity and pressure on the right side of the tube membrane. \n", + "\n", + "The analytical solution to this test for the velocity, pressure and density, looks like the plots in Figure 2." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![shock_analytic](./figures/shock_tube_.01.png)\n", + ". \n", + "\n", + "#### Figure 2. Analytical solution for Sod's first test." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The Richtmyer method" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For this exercise, you will be using a new scheme called the Richtmyer method. Like the MacCormack method that we learned in [lesson 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_02_convectionSchemes.ipynb), Richtmyer is a *two-step method*, given by:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\underline{\\mathbf{u}}^{n+\\frac{1}{2}}_{i+\\frac{1}{2}} &= \\frac{1}{2} \\left( \\underline{\\mathbf{u}}^n_{i+1} + \\underline{\\mathbf{u}}^n_i \\right) - \n", + "\\frac{\\Delta t}{2 \\Delta x} \\left( \\underline{\\mathbf{f}}^n_{i+1} - \\underline{\\mathbf{f}}^n_i\\right) \\\\\n", + "\\underline{\\mathbf{u}}^{n+1}_i &= \\underline{\\mathbf{u}}^n_i - \\frac{\\Delta t}{\\Delta x} \\left(\\underline{\\mathbf{f}}^{n+\\frac{1}{2}}_{i+\\frac{1}{2}} - \\underline{\\mathbf{f}}^{n+\\frac{1}{2}}_{i-\\frac{1}{2}} \\right)\n", + "\\end{align}\n", + "$$\n", + "\n", + "The flux vectors used in the second step are obtained by evaluating the flux functions on the output of the first step:\n", + "\n", + "$$\n", + "\\underline{\\mathbf{f}}^{n+\\frac{1}{2}}_{i+\\frac{1}{2}} = \\underline{\\mathbf{f}}\\left(\\underline{\\mathbf{u}}^{n+\\frac{1}{2}}_{i+\\frac{1}{2}}\\right)\n", + "$$\n", + "\n", + "The first step is like a *predictor* of the solution: if you look closely, you'll see that we are applying a Lax-Friedrichs scheme here. The second step is a *corrector* that applies a leapfrog update. Figure 3 gives a sketch of the stencil for Richtmyer method, where the \"intermediate time\" $n+1/2$ will require a temporary variable in your code, just like we had in the MacCormack scheme." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![richtmyer](./figures/richtmyer.png)\n", + "\n", + "\n", + "#### Figure 3. Stencil of Richtmyer scheme." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Coding assignment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Your mission, should you wish to accept it, is to calculate the pressure, density and velocity across the shock tube at time $t = 0.01 s$ using the Richtmyer method. Good luck!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reference" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Sod, Gary A. (1978), \"A survey of several finite difference methods for systems of nonlinear hyperbolic conservation laws,\" *J. Comput. Phys.*, Vol. 27, pp. 1–31 DOI: [10.1016/0021-9991(78)90023-2](http://dx.doi.org/10.1016%2F0021-9991%2878%2990023-2) // [PDF from unicamp.br](http://www.fem.unicamp.br/~phoenics/EM974/TG%20PHOENICS/BRUNO%20GALETTI%20TG%202013/a%20survey%20of%20several%20finite%20difference%20methods%20for%20systems%20of%20nonlinear%20hyperbolic%20conservation%20laws%20Sod%201978.pdf), checked Oct. 28, 2014." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "###### The cell below loads the style of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/03_wave/README.md b/2-finite-difference-method/lessons/03_wave/README.md new file mode 100644 index 0000000..100f29b --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/README.md @@ -0,0 +1,48 @@ +# Module 3: +## Riding the wave: convection problems + +## Summary + +This module explores in depth the solution of transport problems and conservation laws using numerical methods. + +* [Lesson 1](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_01_conservationLaw.ipynb) discusses the meaning and mathematical representation of a conservation law. +The application that will motivate this module is traffic flow, and it is described here. +The first problem to tackle is the impulsive start of traffic upon a red light turning green. +But instability develops wiith the simple forward-time/backward-space scheme: we need upwind methods. + +* [Lesson 2](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_02_convectionSchemes.ipynb) moves on to a red-light problem, creating a back-moving shock wave. The lesson explores different numerical schemes: +Lax-Friedrichs, Lax-Wendroff and MacCormack. + +* [Lesson 3](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_03_aBetterModel.ipynb) focuses on an improved model for traffic flow, requiring symbolic calculations (with SymPy). + +* [Lesson 4](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/03_wave/03_04_MUSCL.ipynb) is an introduction to the finite-volume method, including study of the conservative discretization, Godunov's method and the MUSCL method. + +## Badge earning +Completion of this module in the online course platform can earn the learner the Module 3 badge. + +### Description: What does this badge represent? +The earner completed Module 3 of the course "Practical Numerical Methods with Python" (a.k.a., numericalmooc). + +### Criteria: What needs to be done to earn it? +To earn this badge, the learner needs to complete the graded assessment in the course platform including: +answering quiz questions involving symbolic calculations with the improved traffic model, and additional SymPy practice; +answering quiz questions on convergence and truncation error; +completing the individual coding assignment using "Sod's shock-tube" problem and answering the numeric questions online. +Earners should also have completed self-study of the four module lessons, by reading, reflecting on and writing their own version of the codes. This is not directly assessed, but it is assumed. Thus, earners are encouraged to provide evidence of this self-study by giving links to their code repositories or other learning objects they created in the process. + +### Evidence: Website (link to original digital content) +Desirable: link to the earner's GitHub repository (or equivalent) containing the solution to the "Sod's shock-tube" coding assignment. Optional: link to the earner's GitHub repository (or equivalent) containing other codes, following the lesson. + +### Category: +Higher education, graduate + +### Tags: +engineering, computation, higher education, numericalmooc, python, gwu, george washington university, lorena barba, github + +### Relevant Links: Is there more information on the web? + +[Course About page](http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/about) + +[Course wiki](http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/wiki/GW.MAE6286.2014_fall/) + +[Course GitHub repo](https://github.com/numerical-mooc/numerical-mooc) diff --git a/2-finite-difference-method/lessons/03_wave/figures/1Dcontrolvolume.png b/2-finite-difference-method/lessons/03_wave/figures/1Dcontrolvolume.png new file mode 100644 index 0000000..9e36b7e Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/1Dcontrolvolume.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/1Dfluxbalance.png b/2-finite-difference-method/lessons/03_wave/figures/1Dfluxbalance.png new file mode 100644 index 0000000..debb3a9 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/1Dfluxbalance.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/FD-stencil_FTCS.png b/2-finite-difference-method/lessons/03_wave/figures/FD-stencil_FTCS.png new file mode 100644 index 0000000..ef07d81 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/FD-stencil_FTCS.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/FD-stencil_LF.png b/2-finite-difference-method/lessons/03_wave/figures/FD-stencil_LF.png new file mode 100644 index 0000000..d1d2be0 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/FD-stencil_LF.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/FTBS_stencil.png b/2-finite-difference-method/lessons/03_wave/figures/FTBS_stencil.png new file mode 100644 index 0000000..3ebfe16 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/FTBS_stencil.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/Riemann-shocktube.png b/2-finite-difference-method/lessons/03_wave/figures/Riemann-shocktube.png new file mode 100644 index 0000000..ed097a6 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/Riemann-shocktube.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/calc_sigma.svg b/2-finite-difference-method/lessons/03_wave/figures/calc_sigma.svg new file mode 100644 index 0000000..8bd97ea --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/figures/calc_sigma.svg @@ -0,0 +1,587 @@ + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/03_wave/figures/cell_boundaries.svg b/2-finite-difference-method/lessons/03_wave/figures/cell_boundaries.svg new file mode 100644 index 0000000..1d8efcd --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/figures/cell_boundaries.svg @@ -0,0 +1,673 @@ + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/03_wave/figures/finite_volume.png b/2-finite-difference-method/lessons/03_wave/figures/finite_volume.png new file mode 100644 index 0000000..a6254c2 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/finite_volume.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/finite_volume.svg b/2-finite-difference-method/lessons/03_wave/figures/finite_volume.svg new file mode 100644 index 0000000..1edb2ef --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/figures/finite_volume.svg @@ -0,0 +1,520 @@ + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/03_wave/figures/linear_extrapolation.png b/2-finite-difference-method/lessons/03_wave/figures/linear_extrapolation.png new file mode 100644 index 0000000..1e93316 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/linear_extrapolation.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/linear_extrapolation.svg b/2-finite-difference-method/lessons/03_wave/figures/linear_extrapolation.svg new file mode 100644 index 0000000..4a2e85f --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/figures/linear_extrapolation.svg @@ -0,0 +1,673 @@ + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/03_wave/figures/linear_reconstruction.png b/2-finite-difference-method/lessons/03_wave/figures/linear_reconstruction.png new file mode 100644 index 0000000..511f0a9 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/linear_reconstruction.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/linear_reconstruction.svg b/2-finite-difference-method/lessons/03_wave/figures/linear_reconstruction.svg new file mode 100644 index 0000000..aa04952 --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/figures/linear_reconstruction.svg @@ -0,0 +1,582 @@ + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/03_wave/figures/many_Rieman_problems.png b/2-finite-difference-method/lessons/03_wave/figures/many_Rieman_problems.png new file mode 100644 index 0000000..fb87463 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/many_Rieman_problems.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/massconservation-CV.png b/2-finite-difference-method/lessons/03_wave/figures/massconservation-CV.png new file mode 100644 index 0000000..8ddbaa4 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/massconservation-CV.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/pipe1.png b/2-finite-difference-method/lessons/03_wave/figures/pipe1.png new file mode 100644 index 0000000..c97a02d Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/pipe1.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/pipe1.svg b/2-finite-difference-method/lessons/03_wave/figures/pipe1.svg new file mode 100644 index 0000000..70f01ac --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/figures/pipe1.svg @@ -0,0 +1,695 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/03_wave/figures/richtmyer.png b/2-finite-difference-method/lessons/03_wave/figures/richtmyer.png new file mode 100644 index 0000000..e51ea15 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/richtmyer.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/shock_tube_.01.png b/2-finite-difference-method/lessons/03_wave/figures/shock_tube_.01.png new file mode 100644 index 0000000..d8d0814 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/shock_tube_.01.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/shocktube.png b/2-finite-difference-method/lessons/03_wave/figures/shocktube.png new file mode 100644 index 0000000..6bd7caa Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/shocktube.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/squarewave.png b/2-finite-difference-method/lessons/03_wave/figures/squarewave.png new file mode 100644 index 0000000..9144745 Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/squarewave.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/velocity_and_flux.png b/2-finite-difference-method/lessons/03_wave/figures/velocity_and_flux.png new file mode 100644 index 0000000..1255d5b Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/velocity_and_flux.png differ diff --git a/2-finite-difference-method/lessons/03_wave/figures/velocityvsdensity.png b/2-finite-difference-method/lessons/03_wave/figures/velocityvsdensity.png new file mode 100644 index 0000000..7b67c8f Binary files /dev/null and b/2-finite-difference-method/lessons/03_wave/figures/velocityvsdensity.png differ diff --git a/2-finite-difference-method/lessons/03_wave/traffic.py b/2-finite-difference-method/lessons/03_wave/traffic.py new file mode 100644 index 0000000..6f191af --- /dev/null +++ b/2-finite-difference-method/lessons/03_wave/traffic.py @@ -0,0 +1,49 @@ +""" +Implementation of functions for the traffic model. +""" + +import numpy + + +def rho_red_light(x, rho_max): + """ + Computes the "red light" initial condition with shock. + + Parameters + ---------- + x : numpy.ndarray + Locations on the road as a 1D array of floats. + rho_max : float + The maximum traffic density allowed. + + Returns + ------- + rho : numpy.ndarray + The initial car density along the road as a 1D array of floats. + """ + rho = rho_max * numpy.ones_like(x) + mask = numpy.where(x < 3.0) + rho[mask] = 0.5 * rho_max + return rho + + +def flux(rho, u_max, rho_max): + """ + Computes the traffic flux F = V * rho. + + Parameters + ---------- + rho : numpy.ndarray + Traffic density along the road as a 1D array of floats. + u_max : float + Maximum speed allowed on the road. + rho_max : float + Maximum car density allowed on the road. + + Returns + ------- + F : numpy.ndarray + The traffic flux along the road as a 1D array of floats. + """ + F = rho * u_max * (1.0 - rho / rho_max) + return F diff --git a/2-finite-difference-method/lessons/04_spreadout/04_00_Python_Function_Quirks.ipynb b/2-finite-difference-method/lessons/04_spreadout/04_00_Python_Function_Quirks.ipynb new file mode 100644 index 0000000..e81bff3 --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/04_00_Python_Function_Quirks.ipynb @@ -0,0 +1,490 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2015 G.F. Forsyth." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Python Names" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We introduced functions way back in Module 1 and they have served us well (and will continue to do so!). There are a few behaviors that bear closer examination before we dive too deeply into the next lessons. These are all common Python gotchas! that will continue to rear their heads, so it's better that you know about them now to avoid a large amount of hair-pulling when they crop up. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There is a [fantastic talk](https://www.youtube.com/watch?v=_AEJHKGk9ns) from PyCon 2015 by Ned Batchelder on YouTube that will walk you through all of the things below and more, but we'll also include a short summary of some of the issues." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Assigning variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When we want a variable `x` to have a value of 5, we assign the *name* `x` to the *value* `5`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], + "source": [ + "x = 5\n", + "print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Integers are immutable. They don't change. If we assign another name `y` to be equal to `x`, there is no operation we can perform on `y` that will change `x` (or the 5). " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "5\n" + ] + } + ], + "source": [ + "y = x\n", + "print(y)\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n", + "5\n" + ] + } + ], + "source": [ + "y += 1\n", + "print(y)\n", + "print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some datatypes *are* mutable, however, and that's where the trouble can start. If instead of an integer, `x` points to a list (lists are mutable), then things are different." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 5]\n" + ] + } + ], + "source": [ + "x = [1, 2, 3]\n", + "y = x\n", + "y.append(5)\n", + "print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What happened? We created a list `[1, 2, 3]` and pointed the name `x` at it. Then we pointed the name `y` at the *same* list. When we add a value to the list, there is only the one list, so the changes to it are reflected whether we ask for it by its first name, `x`, or its second name, `y`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What does this have to do with functions?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A reasonable question. When you call a function and send it a few names (inputs), that action doesn't create copies of the objects that those names point to. It just creates a *new* name that points at the *same* data.\n", + "\n", + "Let's create a simple function that adds a value to a list and then returns a \"copy\" of that list." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def add_to_list(mylist):\n", + " mylist.append(7)\n", + " \n", + " newlist = mylist.copy()\n", + " \n", + " return newlist" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "mylist = [1, 2, 3]\n", + "newlist = add_to_list(mylist)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We send in `mylist`, make a change to it, then make a copy of it and return the copy. But we didn't return `mylist` so those changes are discarded, right?" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 7]\n" + ] + } + ], + "source": [ + "print(newlist)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 7]\n" + ] + } + ], + "source": [ + "print(mylist)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wrong. We sent in the name `mylist` and then appended a value to it. At that point, the list has been changed. We used the `copy()` command to create `newlist`, so it points to a different list than `mylist`, but `mylist` has still been altered by the function. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What if we change the names?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Is this because the function expects a list named `mylist` and that is what we sent? Alas, no. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2, 4, 2, 7]\n" + ] + } + ], + "source": [ + "T = [2, 4, 2]\n", + "newlist = add_to_list(T)\n", + "print(T)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When we send the name `T` to the function `add_to_list`, the function creates the new name `mylist` and points it to the same list that `T` points to." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What do we do?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The most important thing is to be aware of this behavior. It's a feature of the language and it doesn't often cause problems, but you need to know about it for when it does cause problems. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/04_spreadout/04_01_Heat_Equation_1D_Explicit.ipynb b/2-finite-difference-method/lessons/04_spreadout/04_01_Heat_Equation_1D_Explicit.ipynb new file mode 100644 index 0000000..964389e --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/04_01_Heat_Equation_1D_Explicit.ipynb @@ -0,0 +1,822 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, C.D. Cooper, G.F. Forsyth." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Spreading out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You've reached the fourth module of the open course [**\"Practical Numerical Methods with Python\"**](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about), titled *Spreading out: Parabolic PDEs*. We hope that you are enjoying the ride of [#numericalmooc](https://twitter.com/hashtag/numericalmooc) so far!\n", + "\n", + "We introduced finite-difference methods for partial differential equations (PDEs) in the [second module](https://github.com/numerical-mooc/numerical-mooc/tree/master/lessons/02_spacetime), and looked at convection problems in more depth in [module 3](https://github.com/numerical-mooc/numerical-mooc/tree/master/lessons/03_wave). Now we'll look at solving problems dominated by diffusion.\n", + "\n", + "Why do we separate the discussion of how to solve convection-dominated and diffusion-dominated problems, you might ask? It's all about the harmony between mathematical model and numerical method. Convection and diffusion are inherently different physical processes.\n", + "\n", + "The titles of the course modules are meant to spark your imagination: \n", + "\n", + "* _Riding the wave_—imagine a surfer on a tall wave, moving fast towards the beach ... convection implies transport, speed, direction. The physics has a directional bias, and we discovered that numerical methods should be compatible with that. That's why we use _upwind_ methods for convection, and we pay attention to problems where waves move in opposite directions, needing special schemes.\n", + "\n", + "* _Spreading out_—now imagine a drop of food dye in a cup of water, slowly spreading in all directions until all the liquid takes a uniform color. [Diffusion](http://en.wikipedia.org/wiki/Diffusion) spreads the concentration of something around (atoms, people, ideas, dirt, anything!). Since it is not a directional process, we need numerical methods that are isotropic (like central differences)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "Image(url='http://upload.wikimedia.org/wikipedia/commons/f/f9/Blausen_0315_Diffusion.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Parabolic PDEs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You already met the simplest parabolic PDE—the [1-D diffusion equation](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_03_1DDiffusion.ipynb)—in module 2. Its main feature is that it has a second-order derivative in space. Here it is again:\n", + "\n", + "$$\n", + "\\frac{\\partial u}{\\partial t} = \\alpha \\frac{\\partial^2 u}{\\partial x^2}\n", + "$$\n", + "\n", + "Check out the article on [parabolic PDEs](http://en.wikipedia.org/wiki/Parabolic_partial_differential_equation) in Wikipedia. Now compare with the diffusion equation above, with the two independent variables here being $x, t$. You'll see that with no mixed derivatives, and only one second-order derivative (in the spatial variable $x$), it satisfies the condition of a parabolic PDE. Work it out on a piece of paper if you need to.\n", + "\n", + "In the previous module, discussing hyperbolic conservation laws, we learned that solutions have characteristics: information travels along certain paths on space-time phase space. In contrast, parabolic equations don't have characteristics, because any local change in the initial condition will eventually affect the entire domain, although its effect will be felt at smaller intensity with longer distances. This is typical of diffusion processes.\n", + "\n", + "In this first lesson of the module, we first review the 1D diffusion equation and then take a deeper look into the issue of boundary conditions. In the next notebook, we'll introduce _implicit discretizations_ for the first time, which will take us to the land of linear solvers. In the third lesson we'll graduate to two dimensions—more boundary condition and stability issues will come up. We'll then study 2D implicit methods, and go into Crank-Nicolson method: perhaps the most popular of them all. _Enjoy!_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Heat conduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Heat conduction is a diffusive process. Let's remind ourselves of the heat equation in one spatial dimension:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial T}{\\partial t} = \\alpha \\frac{\\partial^2 T}{\\partial x^2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Here, $\\alpha$ is the thermal diffusivity, a property of the material, and $T$ is the temperature.\n", + "\n", + "In the [third lesson of module 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_03_1DDiffusion.ipynb), we discretized the diffusion equation with a forward-time, centered-space scheme, subject to the following stability constraint:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\alpha \\frac{\\Delta t}{(\\Delta x)^2} \\leq \\frac{1}{2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Let's look into it more deeply now, using a 1D temperature-evolution problem." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem set up" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Say we have a graphite rod, with [thermal diffusivity](http://en.wikipedia.org/wiki/Thermal_diffusivity) of $\\alpha=1.22\\times10^{-3} {\\rm m}^2/{\\rm s}$, length $L=1{\\rm m}$, and temperature $T=0{\\rm C}$ everywhere. At time $t=0$, we raise the temperature on the left-side end, $x=0$, to $T=100{\\rm C}$, and hold it there. *How will the temperature evolve in the rod?*\n", + "\n", + "As usual, start by importing some libraries and setting up the discretization. We'll begin by using a spatial grid with 51 points and advance for 100 time steps, using a forward-time/centered scheme." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![graphite-rod](./figures/graphite-rod.png)\n", + ".\n", + "#### Figure 1. Graphite rod, temperature fixed on ends." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "L = 1.0 # length of the rod\n", + "nx = 51 # number of locations on the rod\n", + "dx = L / (nx - 1) # distance between two consecutive locations\n", + "alpha = 1.22e-3 # thermal diffusivity of the rod\n", + "\n", + "# Define the locations along the rod.\n", + "x = numpy.linspace(0.0, L, num=nx)\n", + "\n", + "# Set the initial temperature along the rod.\n", + "T0 = numpy.zeros(nx)\n", + "T0[0] = 100.0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remember the forward-time, centered-space discretization? You should work it out on a piece of paper yourself (if you can't do it without looking it up, it means you need to do this more!).\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{T_{i}^{n+1}-T_{i}^{n}}{\\Delta t}=\\alpha\\frac{T_{i+1}^{n}-2T_{i}^{n}+T_{i-1}^{n}}{\\Delta x^2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "To obtain the temperature at the next time step, $T^{n+1}_i$, from the known information at the current time step, we compute\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "T_{i}^{n+1}=T_{i}^{n}+\\frac{\\alpha\\Delta t}{\\Delta x^2}(T_{i+1}^{n}-2T_{i}^{n}+T_{i-1}^{n})\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Check the [third notebook of module 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_03_1DDiffusion.ipynb), if you need to refresh your memory!\n", + "\n", + "The following function implements this numerical scheme:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def ftcs(T0, nt, dt, dx, alpha):\n", + " \"\"\"\n", + " Computes and returns the temperature along the rod\n", + " after a provided number of time steps,\n", + " given the initial temperature and thermal diffusivity.\n", + " The diffusion equation is integrated using forward \n", + " differencing in time and central differencing in space.\n", + " \n", + " Parameters\n", + " ----------\n", + " T0 : numpy.ndarray\n", + " The initial temperature along the rod as a 1D array of floats.\n", + " nt : integer\n", + " The number of time steps to compute.\n", + " dt : float\n", + " The time-step size to integrate.\n", + " dx : float\n", + " The distance between two consecutive locations.\n", + " alpha : float\n", + " The thermal diffusivity of the rod.\n", + " \n", + " Returns\n", + " -------\n", + " T : numpy.ndarray\n", + " The temperature along the rod as a 1D array of floats.\n", + " \"\"\"\n", + " T = T0.copy()\n", + " sigma = alpha * dt / dx**2\n", + " for n in range(nt):\n", + " T[1:-1] = (T[1:-1] +\n", + " sigma * (T[2:] - 2.0 * T[1:-1] + T[:-2]))\n", + " return T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are all set to run! First, let's use a time step `dt` that satisfies the stability constraint." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the time-step size based on CFL limit.\n", + "nt = 100 # number of time steps to compute\n", + "sigma = 0.5\n", + "dt = sigma * dx**2 / alpha # time-step size\n", + "\n", + "# Compute the temperature along the rod.\n", + "T = ftcs(T0, nt, dt, dx, alpha)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Note\n", + "-----\n", + "In the function `ftcs`, we *copy* the array `T0`; it ensures that the value of `T0` remains unchanged for us to reuse.\n", + "\n", + "Confused? Take a look at [Lesson 0](./04_00_Python_Function_Quirks.ipynb) for a more in-depth explanation.\n", + " \n", + "-----\n", + "\n", + "Now plot the solution!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaQAAAEbCAYAAACV0PCVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XecVNX9//HXZzu9F+lFBZEqFiwYLFijiTH2FhOD+SZffzFf49dYYzQmRmMSY/JVUaNRY+wlsRsVewEUERBQBKTD0pcFtn1+f9y77jhum52ZvbOz7+fD+7g755575zPHZT577z33HHN3REREopYTdQAiIiKghCQiIhlCCUlERDKCEpKIiGQEJSQREckISkgiIpIRIk1IZraLmT1vZup7LiLSykWWkMzsBOAdYGgD9fLN7Fozm29mc8zsbTM7qI66F5rZPDObbWYfmNm30xG7iIikXpRnSL8AJgNvNVDvFuAUYKK7jwT+BrxkZmNjK5nZL4ArgOPcfTRwCfCImR2d8shFRCTlLKqRGswsz90rzOwe4Bx3t1rqDAM+Ac5z97/FlM8Flrj7seHrzsAK4CZ3vyqm3jPAIHffM72fRkREkhXZGZK7VzSi2gmAAa/Glb8CHGFm7cPXRwFt66g3wsyGJxOriIikX6b3shsNVAFfxJUvBvKAETH1qsvj68VuFxGRDJUXdQAN6A6UuntlXPmWcN0tph7A1gbqfYWZTQGmAOQWtR8/dECf5KLNElVVVeTkZPrfKs1DbVFDbVFDbVFj4cKFxe7eIxXHyvSEVJev3W9qSj13nwpMBSjcZTd/8KV3GTegS7KxtXjTpk1j0qRJUYeREdQWNdQWNdQWNcxsaaqOlekpvhhoa2a5ceUdwvX6mHqx5XXVq9fDM5YlHKCIiKRGpiek2QQx9o8rHwxUEPTAq64HMKiWerHb6/Xvj1ZRWtaYvhYiIpJqmZ6QngAcmBRXfgjwortX3zN6Hiito948d5/f0BsV5kLJzgqemb0qqYBFRKRpMjohufsCgns8l5pZdwAz+z7B6A6Xx9TbBFwL/MTMhoT1DgeOBH7emPdqXxDcbtJlOxGRaETWqcHMbiQYqWFA+HpWuGlfdy+LqXoB8EvgLTMrJ+hJd4S7z4o9nrtfb2Y7gKfNrAKoBE5y9+caE0+7PCO/IJfpSzayaF0JQ3u0b3gnERFJmSgfjL3Y3ce6e1d3t/DnsXHJCHcvd/cr3H2Yu4909/3d/Y06jvkndx/h7qPdfZy7P9nYeHIMvjl6F0BnSSIiUcjoS3bN7ZR9gr4Tj81cQXllVcTRiIi0LkpIMfYa0IWhPdpRXLKTV+evjTocEZFWRQkphpl9eZaky3YiIs1LCSnOd/bqR16O8eqCdazdsiPqcEREWg0lpDjd2xdy2B49qaxyHv1gedThiIi0GkpItai+bPfIjOVENV+UiEhro4RUi4N360GvjoUsLt7G+4s3RB2OiEiroIRUi7zcHL47vh8AD01X5wYRkeaghFSHk/cOLts9O2cVW3aURxyNiEj2U0Kqw8Bu7ZgwpCs7yqv416yVUYcjIpL1lJDqceo+AwB4cHr8DOoiIpJqSkj1OGpkbzq1yWfOii3MWbE56nBERLKaElI9ivJzOWFcXwD++b7OkkRE0kkJqQGn7Rtctntq1krNJisikkZKSA0Y1rsD4wZ0pmRnBU9rNlkRkbRRQmqE06o7N+iynYhI2ighNcI3x+xC+8I8PvhiEwvXbI06HBGRrKSE1AhtC/I4fmwfQJ0bRETSRQmpkaov2z3x4Qp2lFdGHI2ISPZRQmqkUf06sWefjmwqLeeFuaujDkdEJOsoISXg1LALuC7biYiknhJSAr41tg9t8nN59/MNfL6uJOpwRESyihJSAjoW5XPs6F0ATUshIpJqSkgJOm3fYFqKR2cup6yiKuJoRESyhxJSgvYa0IXderZn/bYy/vPJmqjDERHJGkpICTIzdW4QEUkDJaQm+M64vhTk5fDmZ8Us21AadTgiIllBCakJurQr4OiRvXGHh2eoc4OISCooITVR9WyyD89YRkWlOjeIiCRLCamJJgzpyuDu7VizZSfTFqyLOhwRkRZPCamJzIxT9gm6gD84XZ0bRESSlfEJycz2NrPnzOwTM/vYzN43s5Pi6uSb2bVmNt/M5pjZ22Z2ULpjO3GvfuTlGK/MX8vqzTvS/XYiIlktoxOSmQ0CXgaKgVHuPgr4G/CwmR0XU/UW4BRgoruPDOu8ZGZj0xlfjw6FTB7RiyqHR9S5QUQkKRmdkIBjgI7AH9y9AsDdbwO2AKcDmNkwYApwvbuvC+vcCXwOXJfuAKufSXpoxjKqqjzdbycikrUyPSFVhOu86gIzM4K4c8OiEwADXo3b9xXgCDNrn84AJ+7anb6d27B843be/Kw4nW8lIpLVMj0hPQjMB64ws/ZmlgNcBhQCt4V1RgNVQHzPgsUEiWxEOgPMyVHnBhGRVMira4OZlQNNuQa1yt0HNj2kGu6+xcwOA+4muI9UAmwGJrv7a2G17kCpu8dP47olXHer6/hmNoXgch89evRg2rRpTYqzX3kVBrwwZzX/euFVOhZak46TKUpKSprcFtlGbVFDbVFDbZEedSYkggRwZ4LHM+DkpocTd7Dg/tDLwLNAV2BHePzHzexMd3+ugVjq5e5TgakAw4YN80mTJjU51mdWT+fl+WtZVTSA478xtMnHyQTTpk0jmbbIJmqLGmqLGmqL9KgvIa129ysTPaCZHZtEPPGuBToDP3X37WHZg2Z2CvB3M+tDkDjbmllu3FlSh3C9PoXx1OnUfQfw8vy1PDR9GVMOHkJwq0tERBqrvntIzzfxmE3drzajgOUxyajaQqAHMBiYTfA5+sfVGUzQKeKTFMZTp0OG9aBXx0I+L97Ge4s3NMdbiohklToTkrtf2pQDNnW/OqwFdjGz+DO5gQT3tzYCT4Q/T4qrcwjwortvTWE8dcrLzeHkvcPODZqWQkQkYUn1sgt7vaXTLQTPIV0TdvfGzA4BvgM85O7F7r6A4D7QpWbWPazzfWAocHma4/uKk/fujxk8O2c1m0rLmvOtRURavHoTipn1DYfqed/Mrq2lyuFm9h8z2z0dwbn7o8BRwP7APDObA9xMkGi+F1P1AuAR4K2wzg+BI9x9Vjriqkv/rm05aNfulFVU8cSHK5rzrUVEWryGznBOAMYBLxEMxxNvLrANmGZmfVMcGwDu/oK7H+Lue7j7SHcf7e43uvvOmDrl7n6Fuw8L6+zv7m+kI56GnBaO3PDAe1/grpEbREQaq6GEdCxwgbtf7u6L4ze6+wp3/xZwL/C/6QiwpTl8j1706FDIp2tLePdzdW4QEWmshhJSX+CORhznGuAbyYfT8hXk5Xx5lnTfu0uiDUZEpAVpKCFV1TICwte4eynB8D0CnLHfAPJyjBfmrtG0FCIijZTKXnL5KTxWi9arYxFH7tmbyirngfeWRh2OiEiL0FBCWmxmDV6KM7ODAX3zxjhr/2A4vwfeX0ZZhU4eRUQa0lBCuhl4wMwm1lUhnJn1H8CNqQyspdtvcFd279We4pKdPD93ddThiIhkvHoTkrtPI3jo9DUz+9DMbjWzq83sl+HPHwKvATfHjL4tgJlx9v6DALjvnSVRhiIi0iI0eA/J3X8FnEgwId75wFXAL8OfDTje3X+fziBbqhPG9aVDYR7Tl2xk3sotDe8gItKKNapTg7s/4e6jCbqBHxgu/dx9rLs/k84AW7J2hXmcOL4foC7gIiINSaiXnbuvcvd3wmVluoLKJmdOCDo3PPnhSjZvL484GhGRzFVnQjKzq5tywKbul6127dmeA3ftxvbySh6duTzqcEREMlZ9Z0jHN/GYTd0va1V3brj/3aVUVWl8OxGR2tQ3Y2xvM7uURkwFHqddEvFkpcOG96RPpyIWF2/jzc+KOXj3HlGHJCKScepNSMB1TTimHrqJk5ebwxkTBnLjCwu4950lSkgiIrWo75JdfhOXfmmMt8U6ZZ/+FOTm8PL8tSzbUBp1OCIiGae+Kcwrm7honJxadG9fyDGjeuMO/3hPU5yLiMRL9xTkEuPsAwYB8ND0L9hR3uAg6iIirYoSUjMa178zI/t2ZGNpOU/PXhV1OCIiGUUJqRmZGWdPGARofDsRkXhKSM3suDF96NQmn4+Wb+ajZZuiDkdEJGMoITWzNgW5nLJPfwDufUdTSImIVEs4IZnZAWZ2mZldF74+yMz0MGwCztxvIGbw79kr2bCtLOpwREQyQqMTkpm1M7PngDeBXwPnhpuOBz42s0Epjy5LDejWlkm796CsooqHZyyLOhwRkYyQyBnS9UAX4DhgCLAWwN3/l2COpN+mPLosVjN531IqNb6diEhCCekYYLK7P+PuS4AvH4B19/uB3VMcW1b7xu49GNC1LSs2befV+WujDkdEJHKJJKRyd99az/aOyQbTmuTkGGeFcyXd+646N4iIJJKQSs3sW7VtMLMjAfVhTtBJe/ejMC+H1xeuY3HxtqjDERGJVCIJ6TrgcTN72cyuBbqb2S/M7J/AU8A1aYkwi3VuW8C3xvYBgrmSRERas0YnJHd/DDgLGAZcTjCq92+Ag4Bz3P3faYkwy1V3bnh4xjJKyyqiDUZEJEIJPYfk7g8A/YFRwCHheoC7P5SG2FqFkX07sdeAzmzdUcFTs1ZGHY6ISGQSeQ5pnZmtAAa7+1x3fy1cp73PspmdaGavm9lMM/vczGaY2Vkx2/PN7Fozm29mc8zsbTM7KN1xpUr1WdK97yylGZpTRCQjJXKGlAPs7e6fpyuY2pjZzwguEZ7u7uMJLhkuBA6LqXYLcAow0d1HAn8DXjKzsc0Za1MdPao33dsX8MmqLby3eEPU4YiIRCKRhDTX3eucM8HMvpmCeOKPOYjggdzz3X05gLuXAz8H/hLWGQZMAa5393VhnTuBz2naFOzNrjAvlzPDLuC3v7Yo4mhERKKRSEK608x+bmZ17ZOOXnZnAZvcfXpsobuvdPcZ4csTAANejdv3FeAIM2ufhrhS7pz9B9EmP5dXF6xj/uotUYcjItLsEklIZwEXAavDezQvxi7A0DTEdwCwJLyH9EZ4j+htM/t+TJ3RBKNGxM8LvhjIA0akIa6U69Ku4MtRwKe+1qxXRUVEMkJeAnUnALNiXreJ227Jh/M1/YFBBJfoTiAYP+9E4J9mtou7Xwd0B0rdPX5O8OrTjG51HdzMphBc7qNHjx5MmzYtpcEnas+8KnIMnpq1ggM7bqBbm2hmBykpKYm8LTKF2qKG2qKG2iI9EklIn7n7xLo2mtmHKYgnXhHQDrjY3VeHZY+Y2anAZWb2x3r2bTBBuvtUYCrAsGHDfNKkSUmGm7w3t3zIU7NWMreiN1dNiubkbtq0aWRCW2QCtUUNtUUNtUV6JPIn+HENbK8zWSWheuy8WXHlHwJtCS7HFQNtzSw3rk6HcL0+DXGlzZSDhwDw4PQv2FSquZJEpPVIZKSG5Q1UuSDJWGozP1zHx1kZUz47XPePqzMYqAA+SUNcabNnn04cvHsPSssquU8zyopIK5LIg7EH1LcA30tDfNXDEY2OKx8JbAfmAk8ADkyKq3MI8GIDI5RnpB+FZ0n3vL2EHeXxt8ZERLJTIveQ3iT44m9ODwEXAr82s2+6e4mZTQS+C1zj7tuABWY2FbjUzJ529+KwF95Q4Mxmjjcl9h/ajVF9O/Hxis08MnP5l9NUiIhks0QS0iLgR3Fl7YDhBNOY35yqoKq5e6WZHQX8DphrZjuAncB/u/sdMVUvAH4JvGVm5QT3no5w9/h7Ty2CmfGjbwzlJw98wB2vf87p+w4gNycdnRhFRDJHIgnpOnd/uZbyf5nZ3cCfgEdSE1YNd98A/LCBOuXAFeGSFY4a2ZsBXdvyxYZSnpuzim+O7hN1SCIiaZVIp4Z76tm2jq/f55Ek5OYYPwzvJd3+2ucadFVEsl4inRr61LL0NbORZnYlwTNDkkInje9Ht3YFfLxiM28valG910VEEpbIc0jLgWVxyxfAR8AvCEbklhQqys/lewcMAuA2DboqIlkukXtIy/j6AKqVBMP5vOfu+hM+Dc7afyC3vraINz4tZu7KzezZp1PUIYmIpEUiCekxd78rbZFIrTq3LeDUfQbwt7cWc/trn/Pn08ZFHZKISFokcsnuqdoKzWw/M7vNzAanKCaJ84OJg8nLMZ75eBXLNpRGHY6ISFokkpDqGsh0NbAZuD/5cKQ2fTu34fgxfaiscu56c3HU4YiIpEUiCanWJzPdfam7XwK0iInwWqop36gZdHXDNg26KiLZp957SGZ2HDWjfPcLh+j5WjWgH5Cf4tgkxvDeHZk0rAfTFqzj3neWcOHhu0cdkohISjXUqWFX4Ojw5w4xP8cqJ5idtd7RFCR5P/rGUKYtWMff317C+QcPpU1B/IwbIiItV72X7Nz9j+7e3937A59U/xy3DHH3w9z9rWaKudXab3BXxvTvzMbSch6esSzqcEREUiqRe0jfTlsU0ihmxn+F95LueONzKiqrIo5IRCR1EhnLrt7Z4szsueTDkYZMHtGbwd3bsXzjdp6ds7rhHUREWohEHozFzHYBTgWGAIVxm/dOVVBSt9wc44cTh3DZEx9z27RFHDd6F8w0NYWItHyNTkhmtg/wH6CMoIPDunBTd4LkpD/Xm8l39urLH15ayLxVW3jzs2Im7tYj6pBERJKWyD2k64Hz3L0HMR0cCCbpuxz4SzoClK8rys/l3AMHARp0VUSyRyIJqbu7f20CPnevcvffAoelLixpyJkTBtKuIJe3PlvPx8s3Rx2OiEjSEklIO2NfmFmHmJ8Lgd1SFZQ0rFObfE7fbwAAf37l04ijERFJXiIJaauZnWPBHfQZwONmdqyZHQs8AaxKS4RSpx8ePIQ2+bm8NG8NH3yxMepwRESSkkhCug04ExgKXBuu/wX8G9gfuCjl0Um9enYo4gcHBYOs/+65+ZrmXERatESeQ3rE3Se7+2fu/gUwGvgm8B1gN3d/M11BSt2mfGMIndvm897iDbz+aXHU4YiINFmjE5KZvR8ugwHcvcTdn3P3J91d34QR6ViUz48nDQXghufnU1WlsyQRaZkSuWS3B/ATd9eEPBnm7P0H0btjEXNXbuGZj3UrT0RapkQS0mx3n17XRjPbKwXxSBMU5edy4eFBJ8ebXlxAuca4E5EWKJGE9KSZnVzP9juTDUaa7rvj+zGkezuWrC/loekaCVxEWp5EEtLuwJ/M7EMze8DMpsYuQP80xSiNkJebw8+PHAbAzS9/yvayyogjEhFJTCKDq54NrCUYu25iLds71FImzejokb0Z1bcTH6/YzN1vL+bHk3aNOiQRkUZL5AxpXh0T9H05gV+6gpTGMTMuOWo4ALdNW8Tm0vKIIxIRabxEEtL5DWw/JZlAJDUO2q07B+7ajS07KrhVA6+KSAuSyIOx71f/bGZ9zGx0+HNOuH1h6sOTpvjfI4OzpLvfWszqzTsijkZEpHESOUPCzE41s4XAMqB6htj7zez31kyzxJnZG2bmZjaoOd6vJRrTvzNHj+zNzooqDbwqIi1GIiM1nAb8HfiIYCy7reGmS4DBwC9SHt3XYzgROKiObe3N7C9mtsDM5pnZi2a2Z7pjylQXHTGMHIOHpi9jcfG2qMMREWlQImdIlwCHu/tJ7n41UArg7ssIeuB9N/Xh1TCzAuC3wLN1VHkEGAeMc/cRwHvANDPrm864MtWuPdtz0vj+VFY5N724IOpwREQalEhCKnD3N2rb4O7bSKwLeVP8hGDai6+NFmFmk4GjgCvdvTQsvhbIBS5Lc1wZ66eH70ZBXg5Pz17FnBWaxE9EMlsiCanIzHrUtsHMepLG55DMrCtwMXUnlxOBcuDLEcfdvQx4K9zWKvXp3IZz9h8IwA0v6CxJRDJbQkMHAW+Y2VlmNhTIMbNeZnYk8AzwcFoiDFwF3O/uS+rYPhpYGSahWIuBXmHCbJV+PGlXOhTm8frCdby9SIOyi0jmSuQy22XACIKODQ4YsDLc9hxB0kg5M9sVOJlgtPG6dKemk0WsLeG6G8EoE/HHngJMAejRowfTpk1LKtZMNXmA8fincMXD07lyQhENdYgsKSnJ2rZIlNqihtqihtoiPRqdkNx9B3CUmR0FHE7wJV8MvOTuL6YpPoAbgOvdvSk3Qer95nX3qcBUgGHDhvmkSZOa8BaZb5/9K3j9xlf5fHMZZT334Mg9e9dbf9q0aWRrWyRKbVFDbVFDbZEeCT2HBODuz7v7z939XHe/OJ3JyMwmAiOBWxuoWkzt97Cqy9anMq6Wpl1hHhccGkxPceMLC6jUJH4ikoESfTC2s5ldZWbPmdlH4fpKM+ucpvgmE/SUm25ms8xsFvCjcNuzYdkxwGygT9g1PNZgYI27f+1yXWtz2r4D6NelDZ+tLeHxD5ZHHY6IyNck8mDsXsAigntFowkSxRjgauAzMxub6uDc/Sp3H+ruY6sX4LZw8zFh2bPA40A+cEBMvAXh68dSHVdLVJCXw0VH7A7An/7zKTvKNT2FiGSWRM6Q/go8DQx0977uPtLd+wADCR5W/b90BNgY4WXDF4BrzaxtWHw5UAX8Jqq4Ms3xY/oyvHcHVmzazj/e+yLqcEREviKRhDTI3c9x9xWxhe6+HPgeMCiFcX2NmR1T2yW7mConEVy6m2VmnxCcHU2Kj7c1y80xLg4n8bvllU/ZsC2+l7yISHQSSUh1zovt7lXA0tgyM+vY1KDqeI9nw0t0vd3d3H1EeAmvevtWd/+Ju+/u7nu4+2R3n5vKGLLBocN7csDQbmwqLefXT8+LOhwRkS8lkpD+GXZo+EpXcTPLM7MrCbtPx5iWbHCSembGb04YRWFeDo9/uII3Pl0XdUgiIkBiCekYguF7VpvZu+Fo2u8Cq4H/Bk4Ly140sxeBoWmIV1JgUPd2/L/Dgm7glz8xh+1l6uAgItFLJCFNAGYRTFVeDrQJ158AC8PXsUuzzI8kTTPl4CEM792BLzaU8qf/aG5FEYleIkMHfebuExtb2cw+bEI80kzyc3O4/sTRnPB/b3Hnm4s5bkwfRvbtFHVYItKKJXKGdFyCx060vjSzsf07c87+g6isci59/GMqKquiDklEWrFGJ6Swe3edwvtGja4vmeHnRw6jT6ciPl6xmXveXhJ1OCLSiiU0qZ6ZHQwcAvQmGKkh1rhUBSXNp31hHr8+YSTfv2cGN724sMGBV0VE0qXRCcnMriYYNmg7sJFgCopYaZugT9Lr0OG9OHb0LjwzexVXPDmH7w3W4Ksi0vwSuYf0A+B4d2/n7v3cvX/sQtDbTlqoXx43go5Feby2cB3vrlI3cBFpfokkpC/c/el6th+RbDASnZ4dirj82GAOxAfm72SjhhUSkWaWSEK618wOqWf7X5MNRqJ18t792W9wV7aWwXXP6oRXRJpXIr3sbge+HY7ScL+ZTY1dCDo7SAtmZvz2O6PIy4FHZy7n7c+Kow5JRFqRROZDuhq4ABgFTAKOjlvUqSELDOnRnuOH5gNw6RMfa94kEWk2iVyy+xFwrDo1ZL9jBuczrFcHlq4v5eaXP406HBFpJRJJSEvd/bl6tqtTQ5bIyzF+e+IozGDq65/zyaotUYckIq1AIgnpCTM7tJ7t6tSQRfYa0IWzJwykssr5xWOzqazSs0kikl6JjNQwFLjAzJYBnwGlcdvVqSHL/PzIYbwwdw0fLd/Mve8s4dwDB0cdkohksUTOkM4GqoC+wDdQp4as16Eon2u/PRKAG19YwIpN2yOOSESyWSIJaV58RwZ1ash+k0f04uiRvSktq+TKJ+fgrkt3IpIeiSSk8xvYfkoygUjm+tXxe9KhKI9X5q/l4RnLog5HRLJUIg/Gvl/9s5n1MbPR4c854XZNO5qlenYs4pfH7QnAlU/NZfbyTRFHJCLZKJEzJMzsVDNbCCwDqruA329mvzczTVmexb47vh+n7zeAsooqfnTfTNaX7Iw6JBHJMomM1HAa8HfgI+BaYGu46RJgMPCLlEcnGeWXx41g3IDOrNy8gwv++aFmmBWRlErkDOkS4HB3P8ndrybs9u3uywh64H039eFJJinMy+XWM8bTvX0Bby9az40vLIg6JBHJIokkpAJ3f6O2De6+jQRnn5WWqXenIv56+l7k5hi3v/45T89eGXVIIpIlEklIRWbWo7YNZtYTPYfUauw3pBuXHxPMnfS/j85mweqtDewhItKwRBLSk8AbZnaWmQ0Fcsysl5kdCTwDPJyWCCUjnXvgIL49tg+lZZX86P6ZbN5eHnVIItLCJZKQLgOWEHRsWAiMBlYCzwJrgKtSHZxkrmDupNHssUtHFhdv438emkWVxrsTkSQk8hzSDnc/CjgG+ANBYvoDcLS7f9PdNed1K9OmIJfbzxxPpzb5vDx/Lbe88lnUIYlIC1ZvRwQzqz7r+czdHwBw9+eB59MdmLQMA7q15eZTx3LuPdP508sLGdWvI4cO7xV1WCLSAjV0hvRfgIVLJMxsrJndYWYzzewjM5tnZn+O72BhZu3N7C9mtiCs86KZ7RlV3K3JpGE9uWjy7rjDTx+cxZLibVGHJCItUEMJabW7/8rd/9Es0dTuQaArcLC7jwEmE0wG+JaZtYmp9wgwDhjn7iOA94BpZta3uQNujX48aVeOGNGLrTsqOP++mWzbWRF1SCLSwjSUkBp9l9rMLk0ylvpcEj7rhLuvAG4EdiO4n4WZTQaOAq509+p5mq4Fcgk6Y0ia5eQYN508hiE92rFgzVYueWy2RgYXkYQ0lJAKzKy/mQ1oaAHOSFOMo909/m559dOYXcL1iUA58GZ1hbCTxVvhNmkGHYrymXrWeNoV5PL07FXc9ebiqEMSkRakoYQ0gqCr9+JGLHukI8A6eu/tTnD29nr4ejSwspa6i4Fe4YO70gx27dmBm04eA8Bvn5vP24uKI45IRFoKq++yipmtAm5rzHGAKe7eJ1WB1flGZrnAB8D77v7DsGwhsNPdR8XV/TVwOTDC3b82gaCZTQGmAPTo0WP8ww/r2V6AkpIS2rdvn9QxHl1YxtOfl9MhH64+oA3d2iQ0sHzGSEVbZAu1RQ21RY1DDjlkprvvnYpjNTT+3GrjSfjhAAAVQklEQVR3/1VjDmRmR6Ugnsa4EqgAftaIuvX2DnT3qcBUgGHDhvmkSZOSDi4bTJs2jWTbYuLBzua73+eNT4u5fX4u/zhvAj06FKYmwGaUirbIFmqLGmqL9EhZpwZ3n5BkLA0ys3OBkwkexi2J2VRM7WPpVZetT3ds8lW5OcafTx3Hbj3bs3BNCadOfYc1W3ZEHZaIZLDGdmqodVDV5mRmZwEXAYe6+9q4zbOBPmZWEFc+GFhTS31pBl3aFfDglAkM792BReu2ccrt77By0/aowxKRDNVQQmoPvAbc0Ayx1MnMzqRmPqbVYdk3w3tAAI8D+cABMfsUhK8fa+ZwJUa39oX884cT2LNPR5asL+WUqe+wbENpwzuKSKtTb0Jy90HuPsTdz22ugOKZ2RnAHcA9wOFmdmaYoI4D+oRxvgi8AFxrZm3DXS8HqoDfNHvQ8hVd2hXwwHkTGNOvE8s2bOfUqe+ydL1GcxCRr2oJXZ9uAYoIHoa9L2aZElfvJIJLd7PM7BOCs6NJ4YO0ErFObfO577z92GtAZ1Zs2s4pt7/L5+tKGt5RRFqNjE9I7t7V3a2O5eqYelvd/Sfuvru77+Huk919boShS5yORfnc+4P92HdQV1Zv2cEpU9/ls7Wa3E9EAhmfkCS7tC/M457v78P+Q7qxbutOTrn9Xeav3hJ1WCKSAZSQpNm1Lcjj7nP3YeJu3Vm/rYzTpr7L3JWbow5LRCKmhCSRKMrP5Y6z9+bQ4T3ZWFrO6Xe8x+zlm6IOS0QipIQkkSnKz+W2M8dzxIhebN5ezhl3vMfMpRujDktEIqKEJJEqyMvhr2fsxbGjdmHrzgrOvus9pi/ZEHVYIhIBJSSJXH5uDjefOpZvje3DtrJKzr7rfd5ZpNGeRFobJSTJCHm5Ofzh5LF8Z6++bC+v5Jy73+fed5Zokj+RVkQJSTJGbo7x+++O4ez9B1JWUcVVT83lh/fOZMO22qbEEpFso4QkGSUnx7jmWyP56+l70aEoj/98soajb35dE/2JtAJKSJKRjh29C8/9dCJ7D+zCmi07OePO97jxhfmUV1ZFHZqIpIkSkmSsfl3a8uCUCfy/w3bDgL++uoiTbnuHL9ZrtHCRbKSEJBktLzeH/5m8Ow9O2Z8+nYqYtWwTx/z5DZ6apTFzRbKNEpK0CPsO7sqzP53IUXv2pmRnBT99cBYXPfwRJTsrog5NRFJECUlajM5tC7j1zL34zQmjKMrP4bEPlvPNP7+hIYdEsoQSkrQoZsbp+w3g3/99EMN7d2DJ+lJOvPVtbn9tEVVVemZJpCVTQpIWabdeHXjyJwfyvQMGUV7p/Pa5+Zxz9/uaHl2kBVNCkharKD+Xq4/fkzvP3psubfN549NiDr1pGlc+OYfVm3dEHZ6IJEgJSVq8w0f04vkLD+bbY/tQUeXc9+5SDr7xVa59eh7FJTujDk9EGkkJSbJCr45F/OnUcbx44cEcM6o3ZRVV3PXmYg6+4VVueH4+m0o1/JBIplNCkqyyW68O/N8Z43nm/x3E4Xv0pLSskv+btoiJv3uVm//zKVt3lEcdoojUQQlJstKefTpx5zn78MSPD+CgXbuzdWcFf/zPQibe8Cq3vbaI0jI9vySSaZSQJKuNG9CF+8/bjwenTGCfQV3YVFrO9c/N5+AbpnH3W4vZUV4ZdYgiElJCklZhwpBuPHz+/tz7/X0Z068TxSU7+dW/53HI76dx15uLWbdVnR9EopYXdQAizcXMOHj3HkzcrTv/+WQtN724gPmrt3Lt0/O47pl5HLhrd741ti9H7tmLDkX5UYcr0uooIUmrY2ZMHtGLw4b35MV5q3l05gpeW7iWNz4t5o1Pi7nsiRwO36Mnx4/pS06lRn8QaS5KSNJq5eQYR43chaNG7sKm0jKem7OaJz9cwftLNvDsx6t59uPVtMmD4zZ+xLfG9mXCkG7k5ljUYYtkLSUkEYKBW0/bdwCn7TuAlZu28/TslTw1ayVzV27h4RnLeXjGcnp2KOS4MX341tg+jOrbCTMlJ5FUUkISidOncxumHDyUKQcP5YGnX2F1QV+e+mglS9eXctebi7nrzcUM7NaWCYO7MX5QF/Ye2IXB3dspQYkkSQlJpB592udw+qRh/Gzy7sxatomnZq3k6dlBclq6vpSHZiwDoFu7AvYaGCSnvQd1ZWTfjhTm5UYcvUjLooQk0ghmxrgBXRg3oAtXHLsHH6/YzMylG5m+ZAMzl26kuKSMl+at4aV5awAoyMthTL9OjB/Ylb0HdmH8wC50aVcQ8acQyWxKSCIJysvN+TI5nTdxCO7O0vWlzFi6kZlLNzBjyUY+XVvC9CUbmb5k45f7De3RjuG7dGRwt3YM6t6OweHSpW2+LveJkGUJycx6An8E9g6LPgYudPfl0UUl2c7MGNQ9SDLfHd8PgE2lZXzwRZCQZi7ZyEfLN7Fo3TYWrdv2tf07FuV9mZyqE9WgMGl1aqPnoaT1yJqEZGYFwEvAQmBPwIG/Aa+a2Th3L4kyPmldOrct4NDhvTh0eC8Ayiqq+GTVFhatK2FJ8TYWry8N1sXb2LKjgo+Wb+aj5Zu/dpxu7Qro16UN3dsX0q19QbgupPuXPwfrLm0L1CVdWrysSUjAOcBo4AR3rwAws0uAFcB/ATdGGJu0cgV5OYzp35kx/Tt/pdzdKS4pY8n6IDktKd7GkvXb+HzdNpauL2X9tjLWb2t46owcg67tCujWLkhS3doX0r4wj/aFubQrzKN9YR7tqpeC+LJcOhTmU5Sfo0uHEqlsSkgnAl+4++fVBe6+2szmhduUkCTjmBk9OhTSo0Mh+wzq+pVt7s6aLTtZuXk7xVt3sn5b2ZfrdSU7v/x5fclONpaWU1xSRnFJGaxpWiw5FszCW5CXQ2FeDgV5ORTk5lCQF5RtL9nOXYveC8tit+eQl2Pk5uSQl2vk5lj42sg1Izc3eJ1jYXluTlCeE3z+HDNyDHLMsHBdXWZfKQMzMIzwv2A7NeUWlhP3ujrRVufb2LT71RxsdZR/dZ/PN1XSedmmWtuxrpSejlxvdb5by5RNCWk0weW6eIuBw5o5FpGkmRm9OxXRu1NRg3XLK6vYGCaq9SVlbNhWxtadFWwLl5Ivf6788ueSnRWUllV++fPOiipKyyopLat7BPSFG4tT+RFbtnffijqCrJNNCak7MLOW8i1AWzNr4+7bYzeY2RRgSvhyp5nNSXOMLUV3QN88AbVFDbVFDbVFjWGpOlA2JaS61HlO6+5TgakAZjbD3feuq25roraoobaoobaoobaoYWYzUnWsbJoPqRjoUEt5B6A0/uxIREQySzYlpNnAoFrKBxM8jyQiIhksmxLS48BAMxtUXWBmvYA9gMcasf/U9ITVIqktaqgtaqgtaqgtaqSsLcw9OyYgCx+MnQF8ApwBVAF3AQcBejBWRCTDZc0ZkruXAZOBSmAeQWLqCByqZCQikvmy5gxJpLmZ2a+By4Fz3f2eiMMRSSkz2wW4GzjS3ZvlCdysOUOqjZn1NLN/mNmCcHnUzPo1ct98M7vWzOab2Rwze9vMDkp3zOnS1LYws13M7Fdm9r6ZfRi2x+NmNqo54k6HZH4vYo7RD/ifNIXYbJJtCzMbY2ZPmdkH4e/GAjO7IZ0xp0uS3xe7mNmdYRvMNrO5ZnaZmbXI0XHN7ATgHWBoE/e/0MzmhW3xgZl9u1E7untWLkAB8BHwCMHzVrnA34FPgfaN2P82gpEfeoSvzwO2A2Oj/mzN2RYx7dA/fF0UHqcUGBX1Z2vu34uY49wLPE0wiO/3ov5cUbQFcACwEjgwpuwnwJKoP1tztgXBH/YfAnOAbmHZuPD74vdRf7Ymtsd7wG7APUGaSGjfXxA8hjM0fD0ZKAeObnDfqD94Ghv0h+GXxZCYst4E95gubmDfYQSdIr4fVz4XeCbqz9bMbXEbcF5c2dDweLdE/dmasy1i6u8FLAKObOEJKZnfCyO4T3txXHl+Y754Mm1Jsi1GhPv+LK78KWBV1J+tie2RF64TSkhAZ2AbcE1c+TPA3Ib2z+ZLdrUOtkrQ4eHEBvY9geAf3Ktx5a8AR5hZ+1QG2gySaYv/JpjGI9bKcN0lZRE2n2TaotofCO4d7Ux9eM0qmbY4CBhOcJb4JXcvd/fnUh1oM0imLSrCdfzIN9VnWi2OhzMmNMFRQFtq/+4cYWbD69s5mxPSaIKBVeMtBhq6/zGa4Azpi1r2zSP4i6glaXJbuHuFu1fFFe8erqclH1qzS+b3gvBaeBvgoRTHFYVk2uKAcN0pvIc0N7xf8Gsza5PSKJtHMv9GFgIPAOdXPwdpZocSXKq6JaVRZr7R4Tq+LRfHba9VNiek7sDWWsq/HGy1gX1L3T1+2OMt4bpbCuJrTsm0RW2mEFy+vC/ZwCLQ5LYIb1D/DrjIw+sQLVwyvxf9w/U/gevcfU/gTOB7BJeqWppk/42cAzwLfGpmK4EnCWarvja1YWa87uE6vi0b9d2ZzQmpLsl0X8yuyUea8HnCv/xOAU5295Z+ySpWY9rivwiug7+Z7mAi1pi2qJ4T4y53fx/A3WcTJOzJZvaNdAXXzBpsCzMrJLhEtS8wyN37AJOAS83s8vSG12I06rsmmxNSMoOtFhP8VRR//bf6eOtTEF9zSsnAs2Y2hqB32fHuPi+F8TWnJrWFmXUGLgUuSWNszS2Z34vqv4BnxZV/GK73STK25pZMW/yA4J7axe6+AsDdPwB+D1xrZmNTHWwGq56SI74tG/Xdmc0JKZnBVmcTtE3/uPLBBDcwP0k2uGaW9MCzZjaa4DLEqe7+dupCa3ZNbYsJBP/vHzGzWWY2C7gz3HZNWHZVSiNNv2R+L+aH6/jvkMo6yjNdMm1RfY/p07jyhQRnBi0tOSdjdrgeFFc+OG57rVraL00iGj3Yqpn1MrPYtniCoBvnpLhjHgK86O61XWvOZMm0RXUyego4q/pyVfgg4O1pjjsdmtQW7v68u/d397HVC8GzaQBXhWXXNMsnSJ1kfi+eJUg+8TepR4br6akONs2SaYu14XpA3DEHhuuWdkWl0cysWziOaLXnCZ5RnBRX9RBgnrvPpz5R93dPYz/6AoJs/BBBz7gcgmEwvvKgG3AgwT+sW+P2vw1YAHQPX3+flv1gbJPaguCvv3XArQQ3rauXC4FpUX+25v69iDvWJFr2c0jJ/hv5A7AK2C183Tfc98WoP1tztgXBX/9bgBeBDmHZAOAzgufV2kT9+ZJol3uo4zmk8HPvAJ6LK/9F+J0xJHx9OI18MDZrZ4x19zIzmwz8keBZAid4kjp+sNUSYDPBP6xYFwC/BN4ys3KCa+ZHuHv8NfOMl2Rb/Iqg58yPwiXWa2kLOk1S8HuBmfUk+PKpfh7tGjO7kOAB4pTNnpluKWiLiwnuGTxrZpUED8U+RvDvpkVJpi3cfbGZ7QtcDUw3szKCtngBuNZb4OSgZnYjQbf1AeHr6u+9fT0YyBqCP9A3UPNcIgDufr2Z7QCeNrMKggR+kjfi+TQNrioiIhkhm+8hiYhIC6KEJCIiGUEJSUREMoISkoiIZAQlJBERyQhKSCIikhGUkEREJCMoIYmISEZQQhIRzOxqM/PqgWPNLH5g4aYcs3/M8dzMrk5BqJLFsnboIGm9Yob2GUAwzfpHBKMuFxKMsfUkcHvckDCY2e+Aw9x97wTeqzPBuH5PtsRhpeJ5MGhsqo61DBgLYGYaEkYapDMkyTruvjb8Yv1X+Hqsu49x9+HAT4FvAx+Z2fC4Xdfy9WnrG9KZYOy21jTnjUhaKCFJq+LBxGmHAZsIBgVtG7PtJnf/TmTBibRySkjS6oSjFV9FMHz+DwDM7K9m9kV4r2NQdV0z29/MXjOzD83sIzN7zsxOCLedQDAvENRM0jcrvIyHmV1mZu+b2Uwz+9jM/mlmfWOOvXdYv8zM7jGzi83sHTNbaWa3x80zg5l1NrNbzWypmc0Olz+a2eCYOl3N7I6wzsLw/Y9ualuF8W0wsyVmdoyZvWpmq83sCTPraGYHmtnzZrbCzB4xs05NfS+RyOfb0KIlXQv1z+XShmAG2Gdjyr5HMO3AoPB1B2AjcEb42oAbiJkHimBmzFrnRCI4Cxsd/pxLMLXBB0BuXL0lBNMZHBe+HhHGNiWmTgEwA3idcH4eYDeCy4wXhq8Lw+O/C3QMy74bHuuQBtrq6nra6h6CKReuDF/3CtvlfoJpuwF6h3V+XccxHLg66t8JLZm96AxJWiUP5qgppmZWz9oMI7hHtDjcxwmSyqONfJsJ7j473LcSuB0YB9TWaWKNu/87rDuPYIrwSTHbzwLGA5d52BnD3T8FphIknOo644Ar3H1LWOdRgkSW7BxF7YFbwmOuAd4ETgPuCMtWA28QzAwq0iTqZSetmTWwfQGwBnjSzG4BHnL3hcBfGnn8Lmb2JLArQdKovgQ3BHgvru7CuNcbCM5Eqk0O11+ZGtzdr4h5eTjBmcjbcceaA5xtZvnuXt7I2OOtd/dNcfHFl60nmPJbpEl0hiStUtiZoRuwtK467r4V2A94Avg5sCC8J3NgI44/BniVYArrsR70+jsm3FxYyy6lca+rCC7zVesOlLr7znretjthQoq5nzWL4KxlA0EX+KaKj8/rKMtFpIl0hiSt1WSCL89n66vk7kuB88Mpyk8ErgOeM7NB7r6hnl1PIUg817l7RT31GqsYaGtmhfUkpWKCRDY+vEQo0qLoDElaHTMrAq4huDd0Vz31RpnZZRDcc3L3+4GfEXR2GBRWq74EZuE+481sd2rOgmIfCO2dRNgvhevxcTFeYmYXxdTJI+gUEVtnnJndnsR7izQLJSRpVcxsb+AVgpv0x4SdG+rSDbjIzHYL9zXgAGA18ElYZw2wHegXvr4ZmAA8E77+n3DfAuCSJEK/D5gJXGdm7cJjjiQYJeLFuDo3mVmHsE5Xgs4IC5J4b5HmEXU3Py1aUr0APYFZBPdNPPx5FkHPtTcJ7gd1iNvnrwSjNDgwDziP4J7MTcDH4f5zgaeBUXH7nk9wL2oOwf2morB8CvAZQTJ4OXxfD9/nemBoeNyyMNYnwv3eBkrCZRZQEJZ3Bm4L32tW+FkOjYulus4XBEMmzQB+0og2u5paun0T3AfbEMY4iyBJP9GIsqFxx1G3by0NLuauIaZEWrtw4NNfuntDPQ+benwHfuXuV6fj+JIddMlORCA4G1uTrtG+CS5tljS0j7RuOkMSEZGMoDMkERHJCEpIIiKSEZSQREQkIyghiYhIRlBCEhGRjKCEJCIiGUEJSUREMsL/B8liaD7cd1STAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the temperature along the rod.\n", + "pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel('Distance [m]')\n", + "pyplot.ylabel('Temperature [C]')\n", + "pyplot.grid()\n", + "pyplot.plot(x, T, color='C0', linestyle='-', linewidth=2)\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 100.0);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Boundary Conditions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the rod problem above, we stated that the left-hand side of the rod is held to a temperature $T = 100{\\rm C}$. This is an example of a *boundary condition* (BC): a rule that defines how the problem interacts with the borders of the domain. In this case, the domain spans the length of the rod, from $0 \\leq x \\leq 1$.\n", + "\n", + "There are many types of boundary conditions, and they have an important effect on the solution of the problem. For example, in [module 2, lesson 4](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_04_1DBurgers.ipynb) on Burgers' Equation, we used a periodic boundary condition to \"connect\" the right-hand and left-hand borders of the domain. \n", + "\n", + "We need to discuss boundary conditions in a little more detail, and this is good place to do it. Read on!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dirichlet boundary" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The rod example above uses a *Dirichlet* BC on the left-hand side. A Dirichlet boundary is one in which the border is held to a specific value of the solution variable.\n", + "\n", + "What about the right-hand end of the rod $(x=1)$? In the discretization we set up above, the problem hasn't evolved for long enough time for the heat to travel the full length of the rod. Let's increase the number of time steps, `nt`, and see what happens." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Increase the number of time steps.\n", + "nt = 1000\n", + "\n", + "# Compute the temperature along the rod.\n", + "T = ftcs(T0, nt, dt, dx, alpha)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaQAAAEbCAYAAACV0PCVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xd4FFX3wPHv2VQgFIXQe+9FUBSCJApSFBE7KpZXRH1BgVcRu9gLdrFh7wURUCliIfQOoVfpvUmvIef3x0wkvzVtk93sJjmf59lns3fuzJ69hD2ZmVtEVTHGGGOCzRPsAIwxxhiwhGSMMSZEWEIyxhgTEiwhGWOMCQmWkIwxxoQES0jGGGNCQlATkohUEJEJImJ9z40xppALWkISkR7ATKBWFvUiRORpEVkpIktFZIaIxGVQd4CILBeRxSKyQESuCETsxhhj/C+YZ0gPAh2B6VnUewu4Dminqo2Bj4HfRKR52koi8iDwKNBNVZsCg4ERItLF75EbY4zxOwnWTA0iEq6qySLyKXCLqko6deoBK4DeqvpxmvJlwAZVvdR9XQrYCryiqo+nqTcWqK6qjQL7aYwxxuRW0M6QVDU5G9V6AAJM8ir/E7hERGLc152BohnUaygi9XMTqzHGmMAL9V52TYEUYJNX+XogHGiYpl5quXe9tNuNMcaEqPBgB5CFMsBRVT3tVX7QfS6dph7AoSzq/T8i0gfoA+ApUqJlbNlylIz615XDQiclJQWPJ9T/Vskb1hZnWFucYW1xxurVq/eoaqw/jhXqCSkj2c0amdZT1eHAcICoCnU0+vrXuLxlZZ7p0Zio8LDcxphvJSYmEh8fH+wwQoK1xRnWFmdYW5whIhv9daxQT/F7gKIi4p0dirvPe9PUS1ueUb0MxRYRoiM8jJi/hZs+nM2ewydyFLAxxpicCfWEtBgnxipe5TWAZJweeKn1AKqnUy/t9gwVixBG3NmG8iWimbvhb7oPm87KHQez2s0YY4yfhHpCGgUoEO9VngBMVNXUe0YTgKMZ1Fuuqiuz82ZNKpfkp35taValFFv3H+Oqd2bw2/KdOQ7eGGNM9oV0QlLVVTj3eB4SkTIAIvIfnNkdHklTbz/wNNBXRGq69ToAnYD7fXnPsiWi+a7P+XRvXpEjJ0/T54t5vJO4FltZ1xhjAitonRpEZCjOTA1V3ddJ7qbzVPVkmqr3AE8A00XkFE5PuktUNSnt8VT1BRE5DvwiIsnAaeAaVR3va2zREWG8fl1z6pYrztBfV/HShFWs2XmY569sQnRE4e3sYIwxgRS0hKSqg7JZ7xTOlECPZqPu68DruQwNABGhb0JtapeNYeB3SYxauJX1e44w/OaWlC0e7Y+3MMYYk0ZIX7ILBZ0aleeHu9pQqVQRkjbvp/uw6SzdeiDYYRljTIFjCSkbGlYswZh+bWlV7Sy2HzjO1e/NYNyS7cEOyxhjChRLSNlUJiaKr+5ozdUtK3P8VAr//WoBb/y+xjo7GGOMn1hC8kFUeBhDr27KI10bIAKv/b6aft8s5NhJ75mNjDHG+MoSko9EhDsurMnHt5xLTFQ4Yxdv59r3Z7LjwPFgh2aMMfmaJaQcSqhfllH/bUPVs4uyZOsBLh82jaTN+4MdljHG5FuWkHKhTrnijOnblvNrns2uQye49v2ZjEnaGuywjDEmX7KElEtnFYvki9tbc0PrqpxMTqH/t0kM/XUlKSnW2cEYY3xhCckPIsI8PHtFY57q3ogwj/D2pL+488v5HD6RnUVxjTHGgCUkvxERbr6gOp/ddh4losP5bflOrnpnBpv3HQ12aMYYky9YQvKzuDplGN23LTVji7Fq5yG6vz2dWeuyXI7JGGMKPUtIAVAzNoZR/21L+7qx7Dtykps+nM3XszcFOyxjjAlplpACpGSRCD6+9Vx6x9UgOUV5eNQSnhizlOTTKcEOzRhjQpIlpAAK8wiPXtaQoVc3JTLMw2czN3LLJ3PYf/Rk1jsbY0whYwkpD1zTqgrf9GlNmZhIpq/dyxVvT2ftrkNZ72iMMYWIJaQ80rLa2YzpF0fDCiXYsPcoPd6ewaRVu4IdljHGhAxLSHmoUqki/HD3BXRtUp5DJ5K5/dO5fDBlnc0YbowxWELKc0UjwxnW8xwGdKhDisKz41Zw/4jFnEi2GcONMYWbJaQg8HiEAR3q8s6N51AkIoyRC7bQc/gsdh2yGcONMYWXJaQg6tqkAj/cfQEVS0azYJMtj26MKdwsIQVZo4olGdMvjpZplkf/edG2YIdljDF5zhJSCIgtHsXXd7Tm2lbO8uj3fLPQZgw3xhQ6lpBCRFR4GC9e1ZQnujX8Z8bwPl/M49DxU8EOzRhj8oQlpBAiItzWtgaf3XYeJYtE8PuKXVz5zgw27DkS7NCMMSbgLCGFoLg6ZfipX1vqlI1hza7DdH97OtPW7Al2WMYYE1CWkEJUtdLF+PG/bejQoCwHjp3ilk/m8PG09TaI1hhTYFlCCmHFoyMY3qsVfRNqcTpFeeqX5Tzwgw2iNcYUTJaQQpzHIwzqVJ+3erYgOsLDiPk2iNYYUzBZQsonujWryA93tflnEO3lb01n8Zb9wQ7LGGP8xhJSPtK4kjOI9tzqZ7Hj4HGueW8mY5K2BjssY4zxC0tI+Uxs8Si+6n0+Pc+rwonkFPp/m8Tz41dw2gbRGmPyuZBPSCLSSkTGi8gKEVkiInNE5BqvOhEi8rSIrBSRpSIyQ0TighVzoEWGe3iuRxOe6t6IMI/w/uR13PbpXA4ctUG0xpj8K6QTkohUB/4A9gBNVLUJ8DHwvYh0S1P1LeA6oJ2qNnbr/CYizfM24rwjItx8QXW+vL01ZxeLZMrq3XR/exqrd9pKtMaY/CmkExLQFSgBvKqqyQCq+h5wELgBQETqAX2AF1R1t1vnQ2Ad8Gwwgs5LF9QqzU/92qZZiXY6vy7bEeywjDHGZ6GekJLd5/DUAhERnLjD3KIegACTvPb9E7hERGICHWSwVT6rKCPvbkO3ZhU5cvI0d34xn9d+W22Tsxpj8pVQT0jfAiuBR0UkRkQ8wMNAFPCeW6cpkAJs8tp3PU4ia5hHsQZVkcgw3ry+OQ92qY8IvPHHGu76cj6HTyRnvbMxxoQAyWgqGhE5BeTkT+ztqlotV1H9/zgqAp8A7YHDwAHgP6o62d0+EbhAVYt77dcb+ADoqqrjMzh2H5zLfcTGxrb8/vvv/RV2UC3encx7i05wNBkqxgj9W0RTrlj2//Y4fPgwMTEF/sQyW6wtzrC2OMPa4oyEhIT5qtrKH8cKz2TbHuBDH48nwLU5D8frYM79oT+AccDZwHH3+D+KyE0ZJZo0sWRKVYcDwwHq1aun8fHxuY45FMQD3RKO0OfzeazZdZhn557irRvOoX3d2Gztn5iYSEFpi9yytjjD2uIMa4vAyCwh7VDVx3w9oIhcmot4vD0NlAL6q+oxt+xbEbkO+Mw9e9oDFBWRMFVNO8lb6hnTXj/Gk2/UKFOMUX3bMvC7JH5bvpPbPpnD4M716XNhTZzbcMYYE1oyu44zIYfHzOl+6WkCbEmTjFKtBmKBGsBinM9RxatODZxOESv8GE++EhMVzvs3tWRAhzqkKDw/fiX9v03i2EmbnNUYE3oyTEiq+lBODpjT/TKwC6ggIt5nctVw7m/9DYxyf473qpMATFTVQj0wx+MRBnSoy/u9WlIsMoyfFm3j6vdmsOXvo8EOzRhj/p9c9bJze70F0ls445Cecrt7IyIJwJXAd6q6R1VX4dwHekhEyrh1/gPUAh4JcHz5RqdG5RnVty3VSxdl2baDXD5sOjP+skX/jDGhI9OEIiKV3Kl65ojI0+lU6SAiv4tI3UAEp6o/AJ2BC4DlIrIUeAMn0dyapuo9wAhgulvnDuASVU0KRFz5Vd1yxRnTN472dWPZd+QkvT6aw4dT19mif8aYkJDVGU4PoAXwG850PN6WAUeARBGp5OfYAFDVX1U1QVUbqGpjVW2qqkNV9USaOqdU9VFVrefWuUBVpwYinvyuZNEIPr713H8W/Xtm7AoGfGf3lYwxwZdVQroUuEdVH1HV9d4bVXWrqnYHPgceCESAxv/C3EX/3rvpHIpFhjEmaRtXvjuDzfvsvpIxJniySkiVcAaXZuUpnIGrJh/p3LgCo/u2pUaZYqzYfpBuw6YxZfXuYIdljCmkskpIKV5je9Klqkdxpu8x+UydcsUZ068tHRqUZf/RU9z6yRzGrjtp95WMMXnOn73kIvx4LJOHSkRHMLxXq3/GK41YfYq+Xy/giM2DZ4zJQ1klpPUikuWlOBG5ENjon5BMMKSOV/rg5lYUCYdxS3bQ453prN9zJNihGWMKiawS0hvA1yLSLqMK7sqsXwFD/RmYCY6ODcvx+PlFqF02htU7D3P5sGn8uXJnsMMyxhQCmSYkVU3EGXQ6WUQWisi7IjJERJ5wf14ITAbeSJ192+R/FWI8jO7blk6NynHoeDK3fzaPN35fY+srGWMCKst7SKr6JHAVzoJ4dwKPA0+4Pwtwuaq+HMggTd6LiQrn3RtbMqhTPQBe+301fb6Yz8Hjp4IcmTGmoMpWpwZVHaWqTXG6gbd1H5VVtbmqjg1kgCZ4PB6hb0JtPr71XEpEh/P7ip10HzadVTsK9fSAxpgA8amXnapuV9WZ7mNboIIyoSWhXll+vieO+uWLs37PEa54ezpjkrYGOyxjTAGTYUISkSE5OWBO9zOhrVrpYoz6b1t6tKjEsVOn6f9tEkN+Wsap0zb8zBjjH5mdIV2ew2PmdD8T4opEhvHqtc14unsjIsKET2dsoOfwWew6eDzYoRljCoDMVowtLyIPkY2lwL0Uy0U8JsSJCL0uqE6jSiX575cLmLfxb7q+OY23b2hB65qlgx2eMSYfyzQhAc/m4Jg7chiLyUfOqXoWv9wbR7+vFzBr3T5u+HA2D3Wpz+1xNWyJdGNMjmR2yS4ih4/KAYzXhJAyMVF8eXtr7ryw5j9LWfT7ZqFNOWSMyZHMljA/ncOH3eUuRMLDPDzUtQHv3ugsZTF28XaueHs6f+0+HOzQjDH5TKCXIDeFRJcmFRjTL47aZWNYs+sw3YdNZ8LS7cEOyxiTj1hCMn5Tu2wMY/q25dKmFTh8Ipm7vlzA8+NXkGxdw40x2WAJyfhVsahwhvVswaOXNiDMI7w/eR03fTSbXYesa7gxJnOWkIzfiQi929Xk696tKRMTxax1+7j0zWnMWrc32KEZY0KYJSQTMK1rlmbcvXG0rnE2uw+d4IYPZvFu4l82a7gxJl0+JyQRaSMiD4vIs+7rOBGxwbAmXWVLRPNV79bcHV+LFIUXJ6zkjs/nceCozRpujPn/sp2QRKSYiIwHpgHPALe5my4HlohIdb9HZwqE8DAPgzvX56NbWlEiOpw/Vu7i0remsnjL/mCHZowJIb6cIb0AnAV0A2oCuwBU9QGcNZKe93t0pkC5uEE5xt7bjiaVSrLl72Nc/e5Mvpi1EVW7hGeM8S0hdQU6qupYVd0A/NOXV1W/BOr6OTZTAFU5uyg/3H0BN51flZOnU3hs9FIGfJdkszsYY3xKSKdUNbOV2UrkNhhTOESFh/HMFU144/rmFI0MY0zSNrq/PZ01O23hP2MKM18S0lER6Z7eBhHpBNgNAeOT7s0r8VO/ttQuG8PaXYe5fJgt/GdMYeZLQnoW+FFE/hCRp4EyIvKgiHwDjAGeCkiEpkCrXbY4Y/q25YrmFf9Z+O/R0Us4kXw62KEZY/JYthOSqo4EegH1gEdwZvV+DogDblHVnwMSoSnwikWF89p1zXnmisZEhnn4ctYmrn53Jpv2Hg12aMaYPOTTOCRV/RqoAjQBEtznqqr6XQBiM4WIiHDT+dUYeXcbqpxdhCVbD3Dpm1MZt8QmaDWmsPBlHNJuEdkK1FDVZao62X0OeJ9dEblKRKaIyHwRWSci80SkV5rtESLytIisFJGlIjJDROICHZfxvyaVS/LLPe3o1Kgch04k89+vFvDY6KUcP2WX8Iwp6Hw5Q/IArVR1XaCCSY+IDMS5RHiDqrbEuWS4Grg4TbW3gOuAdqraGPgY+E1EmudlrMY/ShaJ4L2bWjKkW0Miwzx8MWsjV707g/V7jgQ7NGNMAPmSkJapaobXT0TkMj/E433M6jgDcu9U1S0AqnoKuB8Y5tapB/QBXlDV3W6dD4F15GwJdhMCRIRb29Zg5N1tqHp2UZZtO0i3t6bx06JtwQ7NGBMgviSkD0XkfhHJaJ9A9LLrBexX1blpC1V1m6rOc1/2AASY5LXvn8AlIhITgLhMHmlSuSS/3Bv3zxpL936zkId+XGKX8IwpgHxJSL2A+4Ad7j2aiWkfQK0AxNcG2ODeQ5rq3iOaISL/SVOnKc6sEZu89l0PhAMNAxCXyUMloiMY1rOF0wsv3MM3czbZMunGFECS3T4JInIISMqkSjNV9etsDSKyFKgOLME5E9oFXAV8Azyhqs+6yfACVS3utW9v4AOgq6qOz+D4fXAu9xEbG9vy+++/92f4+dbhw4eJiQnNE8uNB0/zTtIJdh5VosLglkZRtKkYHrD3C+W2yGvWFmdYW5yRkJAwX1Vb+eNYvvxPXquq7TLaKCIL/RCPt2igGDBIVXe4ZSNE5HrgYRF5LZN9JauDq+pwYDhAvXr1ND4+PpfhFgyJiYmEcltc1SmZh39cwk+LtjF88Qn+jojlqe6NKRIZ5vf3CvW2yEvWFmdYWwSGL5fsumWxPcNklQupk5t5n5ktBIriXI7bAxQVEe9vo9QzJlumtICJiQrnjeub8/yVTYgK9zBi/hYuHzbN5sIzJp/zZaaGLVlUuSeXsaRnpfvsHefpNOWL3ecqXnVqAMnAigDEZYJMROh5XlVG921LzdhirNl1mG7DpvHd3E22nIUx+ZQvA2PbZPYAbg1AfKnTETX1Km8MHAOWAaMABeK96iQAE7OYodzkcw0qlODnfnFc2aISx0+lMHjkEu75ZiEHjtmKtMbkN77cQ5qG88Wfl74DBgDPiMhlqnpYRNoBVwNPqeoRYJWIDAceEpFfVHWP2wuvFnBTHsdrgqBYVDivXtecuDpleGz0Un5ZvJ2Fm/bzZs/mtKx2drDDM8Zkky8J6S/gLq+yYkB9nGXM3/BXUKlU9bSIdAZeBJaJyHHgBNBPVT9IU/Ue4Alguoicwrn3dImqZtYr0BQwV55TmRZVz+LebxayZOsBrn1/FgM71OHu+NqEebLs42KMCTJfEtKzqvpHOuU/icgnwOvACP+EdYaq7gPuyKLOKeBR92EKsRplijHy7ja8PHEVw6es4+WJq5m2dg+vX9eC8iWjgx2eMSYTvnRq+DSTbbv5930eY4IiMtzDw10b8Nl/zqNMTBSz1u2j8xtT+G35zmCHZozJhC+dGiqm86gkIo1F5DGcMUPGhIz2dWMZ378d7evGsv/oKe74fB5PjLGZw40JVb5csttCxp0ajgO35T4cY/wrtngUn9x6Lh9PX8+LE1by2cyNzF6/j7d6tqBOueJZH8AYk2d8SUib+fcEqqdxpvOZrao2ANWEJI9H6N2uJufXLM093yxk5Y5DdBs2jccva0TP86ogYh0ejAkFviSkkar6UcAiMSbAGlcqyS/3xPHET8v4Yf4WHh61hKlrdvPClU0pWTQi2OEZU+j5MnXQmPQKRaS1iLwnIjX8FJMxAVMsKpyXr2nGG9c3JyYqnPFLd9DljSnM/MtO8I0JNl8SUkYTme4ADgBf5j4cY/JG9+aVGHdvO5pXKcW2A8e54cNZPD9uBSeSrcODMcHiS0JK90K7qm5U1cGAzcVu8pWqpYsy4q4L6H9xHQR4f8o6erw9wyZpNSZIMr2HJCLdODPLd2V3ip5/VQMqA3YR3uQ7EWEeBnasy4V1Yxn4XRLLtx/ksrem8XDXBtx8QbVgh2dMoZJVp4baQBf35+Jpfk7rFM7qrJnOpmBMKGtZ7SzG9W/Hkz8tY8T8LTzx0zL+XLmLHhVTgh2aMYVGpglJVV/DvXckIgtVtUWeRGVMEMREhTP0mmZcVL8sD41awuTVu1mwHopW2cEljcoHOzxjCjxf7iFdEbAojAkhXZpUYEL/C4mrXYZDp6DPF/N5cORijpxIDnZoxhRovsxltzGz7SIyPvfhGBMaypeM5vP/nEfP+pFEhnv4du5mLn1zKgs3/R3s0IwpsHwZGIuIVACuB2oCUV6bW/krKGNCgccjdKoewS2dWzPg2yRW7jjE1e/N5N6L6tA3oRbhYb5cYDDGZCXbCUlEzgV+B07idHDY7W4qg5Ocdvg9OmNCQP3yJRjdty0v/7qKD6et57XfVzN59S5evbY51csUC3Z4xhQYvvyJ9wLQW1VjgRWqWkVVq+As0vcIMCwQARoTCqIjwnj0soZ81bs15UtEs2DTfrq8MZUvZm1ENa8XUjamYPIlIZVR1X8twKeqKar6PHCx/8IyJjS1rV2GCQPacXmzihw7dZrHRi/l5o/nsP3AsWCHZky+50tCOpH2hYgUT/NzFFDHX0EZE8pKFY3kzZ4tePuGcziraART1+zhktem8OOCLXa2ZEwu+JKQDonILeLM1T8P+FFELhWRS4FRwPaARGhMiLq0aQV+HXghHRqU5dDxZP73/SLu+nI+ew6fyHpnY8y/+JKQ3gNuAmoBT7vPPwE/AxcA9/k9OmNCXNni0XxwcyteuropMVHh/LpsJ51em8KEpdbHxxhf+TIOaYSqdlTVtaq6CWgKXAZcCdRR1WmBCtKYUCYiXNuqChMGtKNNrdLsPXKSu76cz/++S+LAsVPBDs+YfCPbCUlE5riPGgCqelhVx6vqaFXdE7gQjckfKp9VlC9vb82Qbg2JjvDw48KtdH59ClPX7M56Z2OMT5fsGgB9VXV9oIIxJr/zeIRb29b4Z62l7QeO0+ujOTw2eilHT9rUQ8ZkxpeEtFhV52a0UUTO8UM8xhQINWNj+OGuCxjUqR4RYcIXszbS5Y2pzNuwL9ihGROyfElIo0Xk2ky2f5jbYIwpSMLDPPRNqM2YvnHUL1+cjXuPcs37M3ny52V2tmRMOnyZy64uMFBEHgJWAIe9tlfxW1TGFCANK5ZgTL+2vPXHWt6d/BefTN/AHyt28eJVTbmgVulgh2dMyPAlId0M7MKZu65dOtuLp1NmjAGiwsO4v1M9Ojcuz/0jFrFyxyF6fjCLXudX48Eu9SkW5dM8x8YUSL5cslueOn9deg+csyZjTCYaVyrJT/3iGNChDuEe597SJa9NYdoa66hqjC8J6c4stl+Xm0CMKSwiwz0M6FCXn/rF0bhSCbbuP8ZNH83moR8Xc/C4jVsyhZcvA2PnpP4sIhVFpKn7s8fdvtr/4RlTcDWsWIJR/23L/ZfUJTLMwzdzNtPptSkkrtoV7NCMCQqfVhgTketFZDWwGUhdIfZLEXnZneMu4ERkqoioiFTPi/czJpAiwjz0u6gOv9wbR7PKJdl+4Di3fjKX+0cs4sBRO1syhYsvMzX0BD4DFuHMZXfI3TQYqAE86Pfo/h3DVUBcBttiRGSYiKwSkeUiMlFEGgU6JmP8oW654oy8uw0PdqlPZLiHH+ZvoeNrk/l9+c5gh2ZMnvHlDGkw0EFVr1HVIcBRAFXdjNMD72r/h3eGiEQCzwPjMqgyAmgBtFDVhsBsIFFEKgUyLmP8JTzMw13tazHu3nacU7UUuw6doPfn8xjw7UL2HTkZ7PCMCThfElKkqk5Nb4OqHsG3LuQ50Rdn2Yt/zRYhIh2BzsBjqnrULX4aCAMeDnBcxvhV7bIxjLirDY9e2oDoCA+jk7Zx8SuJtt6SKfB8SUjRIhKb3gYRKUsAxyGJyNnAIDJOLlcBp4B/ZhxX1ZPAdHebMflKmEfo3a4mE/pfSJtapfn76Cn+9/0ibv54Dpv3Hc36AMbkQz5NHQRMFZFeIlIL8IhIORHpBIwFvg9IhI7HgS9VdUMG25sC29wklNZ6oJybMI3Jd6qXKcZXvVvz0tVNKVnkzOq0H05dR/LplGCHZ4xfSXYvAYhINE5SugRQQNxncHrcXZlOQsh9gCK1gSlAA1U9ICJDgCeAGqkJyu35d0JVm3jt+wzwCNBQVf81cFdE+gB9AGJjY1t+/30gc2r+cfjwYWJiYoIdRkgIpbY4cEL5esUJZu84DUD1Eh5uaxxJtRJhefL+odQWwWZtcUZCQsJ8VW3lj2Nl+76Pqh4HOotIZ6ADUBrYA/ymqhP9EUwGXgJeUNUDOdg3067oqjocGA5Qr149jY+Pz8FbFDyJiYlYWzhCrS26d4I/V+7k0VFL2XDgOE/NOkHvdjUYcHFdikQGNjGFWlsEk7VFYPjcEUFVJwATAhDLv4hIO6AxWc8CsQeomE556n2tvf6My5hguqh+OSb+rzQv/7qKz2Zu4P3J65iwdAfP9WhC29plgh2eMTnm68DYUiLyuIiMF5FF7vNjIlIqQPF1xOkpN1dEkkQkCbjL3TbOLesKLAYqul3D06oB7FRVG/puCpSYqHCGXN6IH+9u88/SFjd+OJv7vl/E39ZF3ORTvgyMPQf4C6eDQVOcRNEMGAKsFZHm/g5OVR9X1Vqq2jz1Abznbu7qlo0DfgQigDZp4o10X4/0d1zGhIoWVc/i53viGNSpHpHhHkYu2EKHVyczJmmrdRE3+Y4vZ0hvA78A1VS1kqo2VtWKQDWcwarvBCLA7HDvYf0KPC0iRd3iR4AU4LlgxWVMXohwFwKc0L8drWuczd4jJ+n/bRK3fDKXjXuPBDs8Y7LNl4RUXVVvUdWtaQtVdQtwK1Ddj3H9i4h0Te+SXZoq1+BcuksSkRU4Z0fx3vEaU1DVjI3hmzvO54Urm1AiOpwpq3fT8bUpvPnHGk4knw52eMZkyZdODZsz2qCqKSKyMW2ZiJRQ1YM5juzf7zGOjKcNQlUP4czmYEyh5fEI159XlQ4Ny/Hc2BX8uHArr/62mtELt/LMFY1pY50eTAjz5QzpG7dDw/9LYiISLiKP4XafTiMxt8EZY3KmTEwUr17XnK/vaE2t2GKs23OEGz6czYBvF7L70Ilgh2dMunw5Q+oKnA/cKyJrgYNACaA2cBpY5M4InqqW36I0xuRIm1plGN//Qj6Yuo43/1jD6KRt/LFyFw90rs8N51UlzJMSDyISAAAcUklEQVQnq8YYky2+nCGdDyThLFV+CijiPq8AVruv0z7sN92YEBAZ7nR6+G1ge+LrxXLoeDKPjV7Kle9MZ+nWnIw3NyYwfDlDWquq7bJbWUQW5iAeY0yAVC1dlE9uPZcJS3fw5M/LWbTlAJcPm8bNF1TnvkvqUjw6ItghmkLOlzOkbj4e29f6xpgAExG6NKnA7/e15/a4GogIn87YwMWvTOaXxdts7JIJqmwnJLd7d4ZE5P/NZ5dVfWNM8MREhfPYZQ35qV9bmldxFgPs9/VCbv54Dmt3HQ52eKaQ8mkuOxG5EEgAyuPM1JBWC38FZYzJG40qluTHu9vw7dzNvDB+BVPX7KHz61O4Pa4G91xch5ioQK+7acwZ2f5tc5d9eBw4BvzNmaUnUgVsgT5jTOB4PMINravSqVE5hv66iu/mbeb9KesYtXArj1zagMubVUTE+iiZwPPlHtLtwOWqWkxVK6tqlbQPnN52xph8qnRMFC9c1ZRR/21Ls8ol2XXoBP2/TeK64bNYsd1vY9yNyZAvCWmTqv6SyfZLchuMMSb4mlcpxaj/tuXFq5pwdrFI5qzfx6VvTuXL5Sc4cOxUsMMzBZgvCelzEUnIZPvbuQ3GGBMaPB7hunOrMum+eG5tUx2A3zclc9HLiXw/dzMpKdYbz/ifLyvGvi8ib4jI88Ba4KhXlcySlTEmHypZNIIhlzfi2lZVGPDFdFb/fZIHRi7mqzmbeLp7I5pWDtRSaKYw8rVTwz04nRoqY50ajCk0GlYswUPnRXPwrLo8O3YFizbvp/vb07n+3CoM6lSfs4t5r41pjO98uWR3F3CpdWowpnASEbo3r8Sf98dz54U1CRPhmzmbiR86iY+nrefU6ZRgh2jyOV8S0kZVHZ/JduvUYEwhEBMVzkNdGzBhwIW0q1OGg8eTeeqX5XR6fQqTVu4KdngmH/MlIY0SkYsy2W6dGowpRGqXjeHz/5zHBze3onrpoqzbfYTbPp3LLR/PYe2uQ8EOz+RDvgzDrgXcIyKbsU4Nxhicy3gdG5ajfd1YPpuxgTf/WMPk1buZ9voeep1fjQEd6lCqqN1fMtnjS0K6GdgFVHIf3qxTgzGFVGS4hzsurMmV51Tild9W8+2cTXw6YwOjFm5lYIc63Hh+NSLCfLkgYwojX35Dlnt3ZLBODcaYtErHRPFcjyaMvbcdbWqV5sCxUwz5eTld3phK4iq7v2Qy50tCujOL7dflJhBjTMHRoEIJvurdmuG9WlKtdFHW7jrMrZ/M5bZPbDZxkzFflp+Yk/qziFQUkabuzx53+2r/h2eMya9EhEsalWfiwAt5qEt9YqLCmbRqN51fn8KTPy9j/9GTwQ7RhBifLuqKyPUishrYDKR2Af9SRF4Wmw7YGJOOqPAw7mxfi0n3x9PzvKqcVuWT6RtoPzSRD6eu40Ty6WCHaEJEthOSiPQEPgMWAU8Dqf06BwM1gAf9Hp0xpsCILR7F81c2Yew9Z+4vPTN2BR1etdVqjcOXM6TBQAdVvUZVh+B2+1bVzTg98K72f3jGmIKmYUXn/tInt55LnbIxbN53jH5fL6THOzOYu2FfsMMzQeRLQopU1anpbVDVI/i4+qwxpvASERLql2V8/3Y8f2UTysREkbR5P9e8N5M7v5jHut3W8aEw8iUhRYtIbHobRKQsNg7JGOOj8DAPPc+ryuRB8dx7cR2KRITx67KdXPLaFJ4Ys5S9h08EO0STh3xJSKOBqSLSS0RqAR4RKScinYCxwPcBidAYU+AViwrnfx3rkjgonutaVSFFlc9mbiR+aCLvJK7l+Cnr+FAY+JKQHgY24HRsWA00BbYB44CdwOP+Ds4YU7iUKxHNi1c3ZVz/drSvG8uhE8m8NGEVF72cyMj5W2xhwALOlwX6jgOdRaQzcDFQBtgD/KaqEwMUnzGmEKpfvgSf/ec8pq7ZzXPjVrJi+0HuG7GIj6atZ3CX+lxYpww20qTgyTQhiUjqWc9aVf0aQFUnABMCHZgxxrSrE8sv95Rh1MKtvDJxFcu3H+SWj+dwQc3SDO5Sn+ZVbMXagiSrS3Z3A+I+gkJEmovIByIyX0QWichyEXnTu4OFiMSIyDARWeXWmSgijYIVtzHGP8I8wtUtKzPp/nge7FKfEtHhzFy3lyvens7dX87nL+uRV2BklZB2qOqTqvpVnkSTvm+Bs4ELVbUZ0BFnMcDpIlIkTb0RQAughao2BGYDiSKS3szkxph8JjoijLva12LqAxdxd3wtoiM8jF+6g0tem8JDPy5mx4HjwQ7R5FJWCSnbdxBF5KFcxpKZwe5YJ1R1KzAUqAN0dd+7I9AZeExVU9dpehoIw+mMYYwpIEoWjWBw5/pMHpRAz/OqAvDNnM20HzqJ58ev4MDRU0GO0ORUVgkpUkSqiEjVrB7AjQGKsamqrvUq2+Y+n+U+XwWcAqalVlDVk8B0d5sxpoApVyKa569swsSBF9K1SXlOJKfw/uR1tHvpT95N/ItjJ62reH6TVS+7hjhdvYPGTSze6uKcvU1xXzcFtqVTdz1wmYiUVVVbjMWYAqhWbAzv3NiSRZv38+KElcz4ay8vTljJpzPWM6BDXa5pWZlwWxwwX5DMJjQUke3Ae9k5DtBHVSv6K7AM30gkDFgAzFHVO9yy1cAJVW3iVfcZ4BGgoar+awFBEekD9AGIjY1t+f33NrYX4PDhw8TExAQ7jJBgbXFGfmgLVWXZ3hRGrD7JxoMpAJQvKvSoE8m55cPw+KmreH5oi7ySkJAwX1Vb+eNYWSWkharaIlsHEpmlquf7I6gs3mcI0A1or6qH3bKMEtKzOPeQ0k1IadWrV09XrVoVmKDzmcTEROLj44MdRkiwtjgjP7VFSooydsl2Xpm4ig17ndvKDSqU4L6Odbm4Qdlcj2HKT20RaCLit4Tkt04NeZSMbgOuBbqkJiPXHtKfSy+1bG+gYzPGhA6PR+jWrCK//a89z/VoQvkS0azYfpDen8+jxzszmLZmjy13EYKy26kh3UlV85KI9ALuAy5K537QYqCiiER6ldcAdtr9I2MKp4gwDze0rkrioHgeu6whpYtFkrR5Pzd9NJueH8xi/kZb7iKUZJWQYoDJwEt5EEuGROQmzqzHtMMtu8y9BwTwIxABtEmzT6T7emQeh2uMCTHREWHcHleDKQ8kMKhTPUpEhzNr3T6uencmt34yh6VbDwQ7REMWvexUtXoexZEhEbkR+AB4DOiQ5tpvO2A7gKpOFJFfgadFpJM7FukRIAV4Lu+jNsaEomJR4fRNqM1N51fjw6nr+HjaehJX7SZx1W66NC7PwI51qVvOVtIJlvywqN5bQDTOYFhvT6b5+RrgBSBJRE4DW4B4dyCtMcb8o2SRCO67pB63tqnO+1PW8dmMDYxfuoMJy3ZwRfNK9L+4DtXLFAt2mIVOyCckVT07m/UOAX0DHI4xpgApHRPFw10bcHtcDYb9uZZv525i1MKt/LRoG9e0rEzfhNpUObtosMMsNGy0mDGm0CtXIpqnr2jMn/fFc03Lyqgq387dTMLLiTz04xK27j8W7BALBUtIxhjjqnJ2UYZe04zf/9eeHi0qkaLKN3M2ET90Eo+MWsI2S0wBZQnJGGO81IyN4bXrmjNxYHu6N69Icory1exNxA9N5LHRS9l3PCXYIRZIlpCMMSYDtcvG8Mb1Lfht4IV0a1aRUykpfDFrIw9MPsYTY5ay86AteeFPlpCMMSYLtcsW562eLfh1wIVc2rQCyQqfzdxIu5cmMeSnZeyyxOQXlpCMMSab6pYrzts3nMMzbYvQtUl5Tian8OmMDbR7aRJP/bycXYcsMeWGJSRjjPFR5eIe3rmxJeP7t6NzI2ctpo+nr6fdi5N48udldikvhywhGWNMDjWoUIL3erVk7L1xXNKwHCeSU/hkunPG9PiYpdYrz0eWkIwxJpcaVSzJ8JtbMe7edv9cyvt85kbaD53Ew6OWsHnf0WCHmC9YQjLGGD9pWLEE79zYkl8HOL3yklOUr2dvIuHlRAb/sJhNey0xZcYSkjHG+Fm98k6vvN8Gnhlg+928zSS8ksh93y9i3e7DWR+kELKEZIwxAVK7rDPA9o/74rm6ZWUARi7YQodXJzPg24Ws3XUoyBGGFktIxhgTYDXKFOPla5ox6b54rj+3Ch4RRidto+NrU+j79QJW7jgY7BBDgiUkY4zJI1VLF+WFq5qSOCieG1tXJdwjjF28nc6vT6X3Z/NI2rw/2CEGlSUkY4zJY5XPKsqzPZow5YEEbrmgGlHhHn5fsZMr3p5Or49mM3vd3mCHGBSWkIwxJkgqlCzCk90bM23wRdzZvibFIsOYumYP1w2fxTXvzWDy6t2oarDDzDOWkIwxJshii0fxUJcGTH/wIvpfXIcS0eHM3fA3t3w8h8uHTefXZTtISSn4ickSkjHGhIhSRSMZ2LEu0x+8iMGd61MmJpIlWw9w5xfz6fzGFMYkbeV0AU5MlpCMMSbEFI+O4O74Wkx94CKe6NaQCiWjWb3zMP2/TeLiVxL5fu5mTiYXvDWZLCEZY0yIKhIZxm1ta5A4KJ7nr2xC1bOLsmHvUR4YuZj4oZP4dPp6jp08Heww/cYSkjHGhLio8DB6nleVP+9rz+vXNad22Ri2HTjOkJ+XE/fin7w9aS0Hjp0Kdpi5ZgnJGGPyifAwD1e0qMTEARfyfq+WNK1ckr1HTjL011XEvfAnL05Yye5DJ4IdZo5ZQjLGmHzG4xE6NSrPmL5t+fL21lxQszSHTiTzbuJfxL34J0+MWcqWv/PfRK7hwQ7AGGNMzogIcXXKEFenDAs2/c07k/7i9xU7+WzmRr6avYnuzStxd3wtapeNCXao2WJnSMYYUwCcU/UsPrylFRMGtKN784qkqDJywRY6vjaZu7+cz5ItB4IdYpYsIRljTAFSv3wJ3ri+BZPuj+eG1lWJ8HgYv3QH3YZNo9dHs5n5196Qnf3BEpIxxhRA1UoX47keTZg6OIE+F9akqDstUc8PZnHluzOYGIKzP1hCMsaYAqxciWge7tqAGQ9exMAOdTmraAQLN+2nzxfz6fT6FEbO38Kp06ExyNYSkjHGFAKlikbSv0Mdpj94EY9d5sz+sGbXYe4bsYj4oYkhMcjWEpIxxhQiRSPDuT2uBpMHJfDS1U2pGVuMrfuP/TPIdtifazhwNDiDbC0hGWNMIRQZ7uHaVlX4fWB73rvpnH8G2b48cTVtX/yT58etYNfB43kaU4FKSCJSVkS+EpFV7uMHEakc7LiMMSZUeTxC58YVGNO3LV/1bk3b2qU5fCKZ96esI+7FSTz04xI27j2SN7HkybvkARGJBH4DIoFGQEPgCDBJRPLHqDBjjAkSEaFt7TJ81ft8xvRtS5fG5TmVksI3czaR8HIi/b5ewNKtgR3LVGASEnAL0BQYrKrJqnoaGAzUBO4OamTGGJOPNKtSindvaslvA9tzTcvKhHmEXxZv57K3pnHLx3OYtS4wY5kKUkK6CtikqutSC1R1B7Dc3WaMMcYHtcvGMPSaZkwelMDtcTUoGhnG5NW7uX74mbFM/lSQElJTYH065euBJnkcizHGFBgVSxXhscsaMn3wv8cy+VNBmly1DJBe6xwEiopIEVU9lnaDiPQB+rgvT4jI0gDHmF+UAfYEO4gQYW1xhrXFGdYWZ9Tz14EKUkLKiGS0QVWHA8MBRGSeqrbKs6hCmLXFGdYWZ1hbnGFtcYaIzPPXsQrSJbs9QPF0yosDR73PjowxxoSWgpSQFgPV0ymvASzJ21CMMcb4qiAlpB+BaiJSPbVARMoBDYCR2dh/eGDCypesLc6wtjjD2uIMa4sz/NYWEqrrYvjKHRg7D1gB3AikAB8BcUALVT0cxPCMMcZkocCcIanqSaAjcBpn7NEKoARwkSUjY4wJfQXmDMmYvCYizwCPALep6qdBDscYvxKRCsAnQCdVzbC3sj8VmDOk9ORmslURiRCRp0VkpYgsFZEZIhIX6JgDJadtISIVRORJEZkjIgvd9vhRRPLtYGN/TMLr1v9fgELMM7ltCxFpJiJjRGSB+7uxSkReCmTMgZLL74sKIvKh2waLRWSZiDwsIhGBjjsQRKQHMBOolcP9B4jIcrctFojIFdnaUVUL5ANnktVFwAic8VZhwGfAGiAmG/u/B6wGYt3XvYFjQPNgf7a8bIs07VDFfR3tHuco0CTYny2vfy/SHOdz4BdAgVuD/bmC0RZAG2Ab0DZNWV9gQ7A/W162Bc4f9guBpUBpt6yF+33xcrA/Ww7bYzZQB/jUSRM+7fsgzjCcWu7rjsApoEuW+wb7gwewQe9wvyxqpikrj3OPaVAW+9bD6RTxH6/yZcDYYH+2PG6L94DeXmW13OO9FezPlpdtkab+OcBfQKd8npBy83shOPdpB3mVR2TniyfUHrlsi4buvgO9yscA24P92XLYHuHus08JCSiFs8rCU17lY4FlWe1fkC/Z5Way1R44/+EmeZX/CVySD5ezyE1b9AM+9irb5j6f5bcI844/JuF9Fefe0Qn/h5enctMWcUB9nLPEf6jqKVUd7+9A80Bu2iLZffae+Sb1TCvfUdXkrGulqzNQlPS/OxuKSP3Mdi7ICSk3k602xTlD2pTOvuE4fxHlJzluC3WW8kjxKq7rPifmPrQ8l6tJeN1r4UWA7/wcVzDkpi3auM8l3XtIy9z7Bc+ISBG/Rpk3cvN/ZDXwNXBn6jhIEbkI51LVW36NMvQ1dZ+923K91/Z0FeSEVAY4lE75P5OtZrHvUXXWVPLeF6C0H+LLS7lpi/T0wbl8+UVuAwuCHLeFe4P6ReA+da9D5HO5+b2o4j5/Azyrqo2Am4BbcS5V5Te5/T9yCzAOWCMi24DRwABVfdq/YYa8Mu6zd1tm67uzICekjOSm+2KedH3MQz5/Hvcvv+uAa1U1v1+ySis7bXE3znXwaYEOJsiy0xbR7vNHqjoHQFUX4yTsjiLSPlDB5bEs20JEonAuUZ0HVFfVikA88JCIPBLY8PKNbH3XFOSElJvJVvfg/FXkff039Xh7/RBfXvLLxLMi0gynd9nlqrrcj/HlpRy1hYiUAh7CWYW4oMjN70XqX8BJXuUL3edzcxlbXstNW9yOc09tkKpuBVDVBcDLwNMi0tzfwYaw1CU5vNsyW9+dBTkh5Way1cU4bVPFq7wGzg3MFbkNLo/leuJZEWmKcxnielWd4b/Q8lxO2+J8nH/7ESKSJCJJwIfutqfcssf9Gmng5eb3YqX77P0dcjqD8lCXm7ZIvce0xqt8Nc6ZQX5Lzrmx2H2u7lVew2t7uvLbL40vsj3ZqoiUE5G0bTEKpxtnvNcxE4CJqpreteZQlpu2SE1GY4BeqZer3IGA7wc47kDIUVuo6gRVraKqzVMfOGPTAB53y57Kk0/gP7n5vRiHk3y8b1I3dp/n+jvYAMtNW+xyn6t6HbOa+5zfrqhkm4iUducRTTUBZ4xivFfVBGC5qq4kM8Hu7x7AfvSRONn4O5yecR6caTD+30A3oC3Of6x3vfZ/D1gFlHFf/4f8PTA2R22B89ffbuBdnJvWqY8BQGKwP1te/154HSue/D0OKbf/R14FtgN13NeV3H0nBvuz5WVb4Pz1fxCYCBR3y6oCa3HGqxUJ9ufLRbt8SgbjkNzPfRwY71X+oPudUdN93YFsDowtsCvGqupJEekIvIYzlkBxRlJ7T7Z6GDiA8x8rrXuAJ4DpInIK55r5Jarqfc085OWyLZ7E6Tlzl/tIa3LAgg4QP/xeICJlcb58UsejPSUiA3AGEPtt9cxA80NbDMK5ZzBORE7jDIodifP/Jl/JTVuo6noROQ8YAswVkZM4bfEr8LTmw8VBRWQoTrf1qu7r1O+989SZyBqcP9D3cWZcIgCq+oKIHAd+EZFknAR+jWZjfJpNrmqMMSYkFOR7SMYYY/IRS0jGGGNCgiUkY4wxIcESkjHGmJBgCckYY0xIsIRkjDEmJFhCMsYYExIsIRljjAkJlpCMMYjIEBHR1IljRcR7YuGcHLNKmuOpiAzxQ6imACuwUweZwivN1D5VcZZZX4Qz63IUzhxbo4H3vaaEQUReBC5W1VY+vFcpnHn9RufHaaW8qTNprL+OtRloDiAiNiWMyZKdIZkCR1V3uV+sP7mvm6tqM1WtD/QHrgAWiUh9r1138e9l67NSCmfutsK05o0xAWEJyRQq6iycdjGwH2dS0KJptr2iqlcGLThjCjlLSKbQcWcrfhxn+vzbAUTkbRHZ5N7rqJ5aV0QuEJHJIrJQRBaJyHgR6eFu64GzLhCcWaQvyb2Mh4g8LCJzRGS+iCwRkW9EpFKaY7dy658UkU9FZJCIzBSRbSLyvtc6M4hIKRF5V0Q2ishi9/GaiNRIU+dsEfnArbPaff8uOW0rN759IrJBRLqKyCQR2SEio0SkhIi0FZEJIrJVREaISMmcvpcxQV9vwx72CNSDzNdyKYKzAuy4NGW34iw7UN19XRz4G7jRfS3AS6RZBwpnZcx010TCOQtr6v4chrO0wQIgzKveBpzlDLq5rxu6sfVJUycSmAdMwV2fB6iDc5lxgPs6yj3+LKCEW3a1e6yELNpqSCZt9SnOkguPua/Lue3yJc6y3QDl3TrPZHAMBYYE+3fCHqH9sDMkUyips0bNHs6s6pmeejj3iNa7+yhOUvkhm29zvqoudvc9DbwPtADS6zSxU1V/dusux1kiPD7N9l5AS+BhdTtjqOoaYDhOwkmt0wJ4VFUPunV+wElkuV2jKAZ4yz3mTmAa0BP4wC3bAUzFWRnUmByxXnamMJMstq8CdgKjReQt4DtVXQ0My+bxzxKR0UBtnKSRegmuJjDbq+5qr9f7cM5EUnV0n//f0uCq+mialx1wzkRmeB1rKXCziESo6qlsxu5tr6ru94rPu2wvzpLfxuSInSGZQsntzFAa2JhRHVU9BLQGRgH3A6vcezJts3H8ZsAknCWsm6vT66+ruzkqnV2Oer1OwbnMl6oMcFRVT2TytmVwE1Ka+1lJOGct+3C6wOeUd3yaQVkYxuSQnSGZwqojzpfnuMwqqepG4E53ifKrgGeB8SJSXVX3ZbLrdTiJ51lVTc6kXnbtAYqKSFQmSWkPTiJr6V4iNCZfsTMkU+iISDTwFM69oY8yqddERB4G556Tqn4JDMTp7FDdrZZ6CUzcfVqKSF3OnAWlHRBaPhdh/+Y+t/SKcbCI3JemTjhOp4i0dVqIyPu5eG9j8oQlJFOoiEgr4E+cm/Rd3c4NGSkN3Cciddx9BWgD7ABWuHV2AseAyu7rN4DzgbHu6/+5+0YCg3MR+hfAfOBZESnmHrMxziwRE73qvCIixd06Z+N0RliVi/c2Jm8Eu5ufPezh7wdQFkjCuW+i7s9JOD3XpuHcDyrutc/bOLM0KLAc6I1zT+YVYIm7/zLgF6CJ17534tyLWopzvynaLe8DrMVJBn+476vu+7wA1HKPe9KNdZS73wzgsPtIAiLd8lLAe+57Jbmf5SKvWFLrbMKZMmke0DcbbTaEdLp949wH2+fGmISTpEdlo6yW13Gs27c9snyIqk0xZUxh5058+oSqZtXzMKfHV+BJVR0SiOObgsEu2RljwDkb2xmo2b5xLm0ezmofU7jZGZIxxpiQYGdIxhhjQoIlJGOMMSHBEpIxxpiQYAnJGGNMSLCEZIwxJiRYQjLGGBMSLCEZY4wJCf8HPDn64OUjk3AAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the temperature along the rod.\n", + "pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel('Distance [m]')\n", + "pyplot.ylabel('Temperature [C]')\n", + "pyplot.grid()\n", + "pyplot.plot(x, T, color='C0', linestyle='-', linewidth=2)\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 100.0);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hmmm ... it looks like we're pinning the right BC to the value $T=0{\\rm C}$, do you agree?\n", + "Now study the code for the `ftcs` function, above, and try to figure out what happens at the right-most point of the spatial grid. \n", + "\n", + "Did you figure it out? \n", + "\n", + "It never updates the value at `T[-1]`! That value is set to zero in the initial condition and stays that way throughout the entire simulation. We effectively have a Dirichlet boundary at *both* ends. The left-hand side of the rod is held to a temperature of $T = 100{\\rm C}$ and the right-hand side is held to $T = 0{\\rm C}$ Because both end temperatures are \"pinned\" to set values, the temperature distribution within the rod will relax (after enough time) to a linear temperature gradient across the length of the rod. \n", + "\n", + "Once the solution is relaxed, no number of extra time steps will make it change. This is an example of a *steady-state solution* and we'll learn more about those in Module 5 of the course.\n", + "\n", + "Dirichlet BCs show up in many engineering applications, among them thermo- dynamics (e.g., setting a surface temperature) and fluid dynamics (e.g., the no-slip conditions at walls in viscous fluids)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Neumann boundary" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Another commonly used BC is the *Neumann* boundary: rather than specifying the value of the solution at the border, they specify the value of the *derivative* of the solution at the border. \n", + "\n", + "In our example, if we apply a Neumann boundary to the right-hand end of the rod, we can represent that mathematically as\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\left. \\frac{\\partial T}{\\partial x} \\right|_{x = 1} = q(t)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "How can we enforce that in code? One easy way is using a finite-difference discretization of the derivative at the boundary. At time step $n$, for $N$ points, that would be\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\left. \\frac{\\partial T}{\\partial x} \\right|_{x=1} \\approx \\frac{T^n_N - T^n_{N-1}}{\\Delta x} = q(t)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "In the context of heat conduction, the space derivative of temperature is the heat flux density $q$, the amount of heat per unit time, per unit area.\n", + "\n", + "For example, if the rod at $x=1$ has some insulating material, no heat is going to be able to get out through that end, and the Neumann boundary condition is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\left. \\frac{\\partial T}{\\partial x} \\right|_{x=1} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Think about what the equation is saying: the change in temperature when moving in the $x$ direction is zero at the right-most edge of the rod. That means that the temperature should be equal on the last two spatial grid points.\n", + "\n", + "To enforce this Neumann boundary condition at the right-hand end of the rod, we add the following line of code:\n", + "\n", + "```Python\n", + "T[-1] = T[-2]\n", + "```\n", + "\n", + "That is, the temperature at the boundary (`T[-1]`) is equal to the temperature directly to its left (`T[-2]`). The spatial gradient is zero and a Neumann condition is satisfied there." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Dirichlet conditions in the rod example were enforced without any extra input from us, but the Neumann condition will require an update at each iteration of the loop.\n", + "\n", + "Finally, Dirichlet and Neumann BCs can sometimes be mixed to better represent the physics of a problem.\n", + "\n", + "Let's revisit the heated-rod problem. This time, the temperature at $x = 0$ will remain fixed at $T = 100{\\rm C}$—that's the Dirichlet condition— and a Neumann BC applies at $x = 1$." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def ftcs_mixed_bcs(T0, nt, dt, dx, alpha):\n", + " \"\"\"\n", + " Computes and returns the temperature along the rod\n", + " after a provided number of time steps,\n", + " given the initial temperature and the thermal diffusivity.\n", + " The diffusion equation is integrated using forward \n", + " differencing in time and central differencing in space.\n", + " The function uses a Dirichlet condition on the left side\n", + " of the rod and a Neumann condition (zero-gradient) on the\n", + " right side.\n", + " \n", + " Parameters\n", + " ----------\n", + " T0 : numpy.ndarray\n", + " The initial temperature along the rod as a 1D array of floats.\n", + " nt : integer\n", + " The number of time steps to compute.\n", + " dt : float\n", + " The time-step size to integrate.\n", + " dx : float\n", + " The distance between two consecutive locations.\n", + " alpha : float\n", + " The thermal diffusivity of the rod.\n", + " \n", + " Returns\n", + " -------\n", + " T : numpy.ndarray\n", + " The temperature along the rod as a 1D array of floats.\n", + " \"\"\"\n", + " T = T0.copy()\n", + " sigma = alpha * dt / dx**2\n", + " for n in range(nt):\n", + " T[1:-1] = (T[1:-1] +\n", + " sigma * (T[2:] - 2.0 * T[1:-1] + T[:-2]))\n", + " # Apply Neumann condition at the last location.\n", + " T[-1] = T[-2]\n", + " return T" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "nt = 1000 # number of time steps to compute\n", + "\n", + "# Compute the temperature along the rod.\n", + "T = ftcs_mixed_bcs(T0, nt, dt, dx, alpha)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the temperature along the rod.\n", + "pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel('Distance [m]')\n", + "pyplot.ylabel('Temperature [C]')\n", + "pyplot.grid()\n", + "pyplot.plot(x, T, color='C0', linestyle='-', linewidth=2)\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 100.0);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now heat is accumulating in the domain. Our insulator works! If you increase the number of time steps `nt` further, you will see that the outflow temperature at $x = 1$ continues to increase." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Explicit schemes and BCs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The numerical schemes we've learned so far are called _explicit_, because we compute the updated solution at $t^{n+1}$ using only known information at time $t^n$. This is simple but has limitations, particularly with the small sizes of time step necessary to obtain stability.\n", + "\n", + "Here's another issue with explicit schemes. Figure 2 shows the superposed stencil of several grid points over three time steps computed using the forward-time, centered scheme. You know that to calculate $T_i^{n+1}$ you use the information from the grid points $i-1, i, i+1$ at the previous time step. Think about what happens at the boundary: any change in the boundary condition will feed into the solution only at the next time step, not immediately. But this contradicts the physics of the problem, as any change on the boundary should be felt right away under the diffusion equation. To include boundary effects on the same time level, we can use an _implicit_ update (subject of the next lesson)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![explicitFTCS-BCeffect](./figures/explicitFTCS-BCeffect.png)\n", + ".\n", + "#### Figure 2. Stencil with explicit scheme over 3 time steps." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Explicit schemes and time step" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's replace the parameter $\\sigma=\\alpha \\frac{\\Delta t}{(\\Delta x)^2}$ into Equation 4 and rearrange it a little bit, grouping together the terms at grid point $i$ on the right-hand side:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "T_{i}^{n+1} = \\sigma T_{i-1}^{n}+(1- 2 \\sigma) T_{i}^{n} + \\sigma T_{i+1}^{n}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "It's helpful to look at a sketch of the stencil for the heat equation with the weights added in for the contribution of each grid point. See Figure 3, which shows the weights for two values of $\\sigma$: $\\frac{1}{2}$ and $1$. Notice that with $\\sigma=\\frac{1}{2}$, the solution variable at the next time step is _independent_ from its own value at the present step, which seems a bit weird. And with $\\sigma=1$, the current value affects negatively the future value—now _that's_ a red flag!\n", + "\n", + "In fact, the solution will develop growing errors with $\\sigma>\\frac{1}{2}$, i.e., become unstable. This limits the time step that can be used quite significantly, because $\\Delta t \\propto (\\Delta x)^2$. This is a serious cost of _explicit_ methods and an incentive to consider _implicit_ alternatives (next lesson)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![stencil-weights](./figures/stencil-weights.png)\n", + ".\n", + "#### Figure 3. Stencils for the heat equation with $\\sigma= \\frac{1}{2}, 1$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "###### The cell below loads the style of the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/04_spreadout/04_02_Heat_Equation_1D_Implicit.ipynb b/2-finite-difference-method/lessons/04_spreadout/04_02_Heat_Equation_1D_Implicit.ipynb new file mode 100644 index 0000000..2596c36 --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/04_02_Heat_Equation_1D_Implicit.ipynb @@ -0,0 +1,806 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, C.D. Cooper, G.F. Forsyth." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Spreading out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome to the second lesson of the course module: \"_Spreading out: parabolic PDEs.\"_ We're studying the heat equation in one spatial dimension:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial T}{\\partial t} = \\alpha \\frac{\\partial^2 T}{\\partial x^2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $\\alpha$ is the thermal diffusivity and $T$ is the temperature.\n", + "\n", + "In the previous lesson, we reviewed the numerical solution of the 1D diffusion equation with a forward-time, centered-space scheme: an _explicit_ scheme. What does that mean? \n", + "\n", + "The solution for $T$ at time step $t^{n+1}$ was calculated using different combinations of $T$ values from the *previous* time step $t^n$. We have complete knowledge of the parts that feed into the solution update at each spatial point. \n", + "\n", + "*Implicit* methods work differently: we will use more data from the \"future\" in the update, including several values of $T$ at $t^{n+1}$. This will make the scheme more difficult to apply, but there are several reasons why it may be worth the effort.\n", + "\n", + "In lesson 1, we discussed two disadvantages of explicit methods: (1) boundary effects drag behind by one time step; (2) stability requirements constrain the time-step to very small values. Both of these issues are resolved by implicit schemes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Implicit schemes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's move things around a bit and try combining the Euler time step with an evaluation of the spatial derivative on the *updated* solution at $t^{n+1}$. The discretized form of the equation is now as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{T_{i}^{n+1}-T_{i}^{n}}{\\Delta t}=\\alpha\\frac{T_{i+1}^{n+1}-2T_{i}^{n+1}+T_{i-1}^{n+1}}{\\Delta x^2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The stencil for this discretization doesn't look anything like the other stencils we've used until now. Check it out." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![stencil-implicitcentral](./figures/stencil-implicitcentral.png)\n", + ".\n", + "#### Figure 1. Stencil of the implicit central scheme." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the previous time-step, we only know $T_i^{n}$, but what about $T_i^{n+1}$, $T_{i-1}^{n+1}$ and $T_{i+1}^{n+1}$? What can we do?\n", + "\n", + "No need to panic! Let's start by putting what we *do know* on the right-hand side of the equation and what we *don't know* on the left. We get:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "-T_{i-1}^{n+1} + \\left( 2 + \\frac{\\Delta x^2}{\\alpha\\Delta t}\\right) T_{i}^{n+1} - T_{i+1}^{n+1} = T_{i}^{n}\\frac{\\Delta x^2}{\\alpha\\Delta t}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "It looks like there are a lot of unknowns and just one equation! \n", + "\n", + "What does it look like with $i=1$?\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "-T_{0}^{n+1} + \\left( 2 + \\frac{\\Delta x^2}{\\alpha\\Delta t}\\right) T_{1}^{n+1} - T_{2}^{n+1} = T_{1}^{n}\\frac{\\Delta x^2}{\\alpha\\Delta t}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "and $i=2$?\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "-T_{1}^{n+1} + \\left( 2 + \\frac{\\Delta x^2}{\\alpha\\Delta t}\\right) T_{2}^{n+1} - T_{3}^{n+1} = T_{2}^{n}\\frac{\\Delta x^2}{\\alpha\\Delta t}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "What about $i=3$?\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "-T_{2}^{n+1} + \\left( 2 + \\frac{\\Delta x^2}{\\alpha\\Delta t}\\right) T_{3}^{n+1} - T_{4}^{n+1} = T_{3}^{n}\\frac{\\Delta x^2}{\\alpha\\Delta t}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Can you see the common element across equations? Here's a little help:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$T_{i}^{n+1}$ also appears in the equation for $T_{i-1}^{n+1}$ and $T_{i+1}^{n+1}$. We might have enough equations if we apply this for all $i$-values at the same time, don't you think? In fact, this is a linear system of equations for the unknown values $T_{i}^{n+1}$ on the spatial grid." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### What about boundary conditions? " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's look at the boundary points of the example from the previous lesson with a Dirichlet BC at $x=0$ and a Neumann BC at $x=1$, discretizing with $N$ mesh points.\n", + "\n", + "The value $T_0^{n+1}$ is known at every time-step from the BC, so putting all unknown terms on the left-hand side of the equation and the known values on the right side yields the following for the $i=1$ equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "-T_{2}^{n+1} + \\left( 2 + \\frac{\\Delta x^2}{\\alpha\\Delta t}\\right) T_{1}^{n+1} = T_{1}^{n}\\frac{\\Delta x^2}{\\alpha\\Delta t} + T_{0}^{n+1}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "That was easy!\n", + "\n", + "On the other hand, for $i=N-2$, the equation reads\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "-T_{N-3}^{n+1} + \\left( 2 + \\frac{\\Delta x^2}{\\alpha\\Delta t}\\right) T_{N-2}^{n+1} - T_{N-1}^{n+1} = T_{N-2}^{n}\\frac{\\Delta x^2}{\\alpha\\Delta t}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The discretized Neumann boundary condition on the right side of the rod is\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{T^{n}_{N-1} - T^{n}_{N-2}}{\\Delta x} = q\n", + "\\end{equation}\n", + "$$\n", + "\n", + "But we can just as easily write that at time step $n+1$ (the boundary conditions apply at every time-step):\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{T^{n+1}_{N-1} - T^{n+1}_{N-2}}{\\Delta x} = q\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Inserting the Neumann boundary condition in the equation for $i=N-2$ yields\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " -T_{N-3}^{n+1} + \\left( 1 + \\frac{\\Delta x^2}{\\alpha\\Delta t} \\right) T_{N-2}^{n+1} = T_{N-2}^{n} \\frac{\\Delta x^2}{\\alpha\\Delta t} + \\Delta x q\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Make sure you work this out with pen and paper: it's important to recognize where these terms come from!\n", + "\n", + "Now we can write the linear system of equations in matrix form as follows:\n", + "\n", + "$$\n", + "[A][x] = [b]+[b]_{b.c.}\n", + "$$\n", + "\n", + "where the matrix of coefficients $[A]$ is a sparse matrix—most of the matrix elements are zero—with three non-zero diagonals. We write below the system expanded out, so you can see the structure of the matrix, with $\\sigma=\\frac{\\alpha\\Delta t}{\\Delta x^2}$:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$\n", + "\\begin{align}\n", + " \\left[\n", + " \\begin{array}{cccccc}\n", + " \\left( 2 + \\frac{1}{\\sigma} \\right) & -1 & 0 & \\cdots & & 0 \\\\\n", + " -1 & \\left( 2 + \\frac{1}{\\sigma} \\right) & -1 & 0 & \\cdots & 0 \\\\\n", + " 0 & & \\ddots & & & \\vdots \\\\\n", + " \\vdots & & & & \\left( 2 + \\frac{1}{\\sigma} \\right) & \\\\\n", + " 0 & \\cdots & & & -1 & \\left( 1 + \\frac{1}{\\sigma} \\right)\n", + " \\end{array}\n", + " \\right] \\cdot \n", + " \\left[\n", + " \\begin{array}{c} \n", + " T_1^{n+1} \\\\\n", + " T_2^{n+1} \\\\\n", + " \\vdots \\\\ \\\\\n", + " T_{N-2}^{n+1}\n", + " \\end{array}\n", + " \\right] =\n", + " \\left[\n", + " \\begin{array}{c} \n", + " T_1^n \\frac{1}{\\sigma} \\\\\n", + " T_2^{n} \\frac{1}{\\sigma} \\\\\n", + " \\vdots \\\\ \\\\\n", + " T_{N-2}^{n} \\frac{1}{\\sigma}\n", + " \\end{array}\n", + " \\right] +\n", + " \\begin{bmatrix}\n", + " T_0^{n+1} \\\\\n", + " 0 \\\\\n", + " \\vdots \\\\\n", + " 0 \\\\\n", + " q\\Delta x\n", + " \\end{bmatrix}\n", + "\\end{align}\n", + "$$\n", + " \n", + "Notice that the Dirichlet boundary condition adds only a term to the right-hand side of the system. The Neumann boundary condition both adds a term to the right-hand side and modifies the matrix $[A]$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem set up" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll re-use the problem from lesson 1: we have a graphite rod, with [thermal diffusivity](http://en.wikipedia.org/wiki/Thermal_diffusivity) $\\alpha=1.22\\times10^{-3} {\\rm m}^2/{\\rm s}$, length $L=1{\\rm m}$, and temperature held at $T=100{\\rm C}$ on the left end, $x=0$, and $0{\\rm C}$ everywhere else initially. We'll compute the evolution of temperature on the length of the rod.\n", + "\n", + "Let's start like we did in the previous lesson: import your libraries and set up the discretization." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "L = 1.0 # length of the rod\n", + "nx = 51 # number of locations on the rod\n", + "dx = L / (nx - 1) # distance between two consecutive locations\n", + "alpha = 1.22e-3 # thermal diffusivity of the rod\n", + "q = 0.0 # temperature gradient on the right side of the rod\n", + "\n", + "# Define the locations along the rod.\n", + "x = numpy.linspace(0.0, L, num=nx)\n", + "\n", + "# Set the initial temperature along the rod.\n", + "T0 = numpy.zeros(nx)\n", + "T0[0] = 100.0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Solving a linear system" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to solve the linear system of equations written above to advance the solution in time. Luckily, we can rely on our friends from SciPy who have developed some nice linear solvers, so we don't need to write our own.\n", + "\n", + "From `scipy.linalg`, let's import `solve`: a function to solve linear systems. Make sure to explore the documentation of [`scipy.linalg`](https://docs.scipy.org/doc/scipy/reference/linalg.html). We'll need to define our own custom functions to generate the coefficient matrix and the right-hand side of the linear system. You should carefully study the code below." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy import linalg" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def lhs_operator(N, sigma):\n", + " \"\"\"\n", + " Computes and returns the implicit operator\n", + " of the system for the 1D diffusion equation.\n", + " We use backward Euler method, Dirichlet condition\n", + " on the left side of the domain and zero-gradient\n", + " Neumann condition on the right side.\n", + " \n", + " Parameters\n", + " ----------\n", + " N : integer\n", + " Number of interior points.\n", + " sigma : float\n", + " Value of alpha * dt / dx**2.\n", + " \n", + " Returns\n", + " -------\n", + " A : numpy.ndarray\n", + " The implicit operator as a 2D array of floats\n", + " of size N by N.\n", + " \"\"\"\n", + " # Setup the diagonal of the operator.\n", + " D = numpy.diag((2.0 + 1.0 / sigma) * numpy.ones(N))\n", + " # Setup the Neumann condition for the last element.\n", + " D[-1, -1] = 1.0 + 1.0 / sigma\n", + " # Setup the upper diagonal of the operator.\n", + " U = numpy.diag(-1.0 * numpy.ones(N - 1), k=1)\n", + " # Setup the lower diagonal of the operator.\n", + " L = numpy.diag(-1.0 * numpy.ones(N - 1), k=-1)\n", + " # Assemble the operator.\n", + " A = D + U + L\n", + " return A" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def rhs_vector(T, sigma, qdx):\n", + " \"\"\"\n", + " Computes and returns the right-hand side of the system\n", + " for the 1D diffusion equation, using a Dirichlet condition\n", + " on the left side and a Neumann condition on the right side.\n", + " \n", + " Parameters\n", + " ----------\n", + " T : numpy.ndarray\n", + " The temperature distribution as a 1D array of floats.\n", + " sigma : float\n", + " Value of alpha * dt / dx**2.\n", + " qdx : float\n", + " Value of the temperature flux at the right side.\n", + " \n", + " Returns\n", + " -------\n", + " b : numpy.ndarray\n", + " The right-hand side of the system as a 1D array of floats.\n", + " \"\"\"\n", + " b = T[1:-1] / sigma\n", + " # Set Dirichlet condition.\n", + " b[0] += T[0]\n", + " # Set Neumann condition.\n", + " b[-1] += qdx\n", + " return b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we'll define a function that steps in time using the implicit central-space scheme. Remember that for an implicit method, a step in time is performed by solving the entire linear system. This is a fundamental difference between implicit and explicit methods, and implies a considerable computational cost." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def btcs_implicit(T0, nt, dt, dx, alpha, q):\n", + " \"\"\"\n", + " Computes and returns the temperature along the rod\n", + " after a given number of time steps.\n", + " \n", + " The function uses Euler implicit in time,\n", + " central differencing in space, a Dirichlet condition\n", + " on the left side, and a Neumann condition on the\n", + " right side.\n", + " \n", + " Parameters\n", + " ----------\n", + " T0 : numpy.ndarray\n", + " The initial temperature distribution as a 1D array of floats.\n", + " nt : integer\n", + " Number of time steps to compute.\n", + " dt : float\n", + " Time-step size.\n", + " dx : float\n", + " Distance between two consecutive locations.\n", + " alpha : float\n", + " Thermal diffusivity of the rod.\n", + " q : float\n", + " Value of the temperature gradient on the right side.\n", + " \n", + " Returns\n", + " -------\n", + " T : numpy.ndarray\n", + " The temperature distribution as a 1D array of floats.\n", + " \"\"\"\n", + " sigma = alpha * dt / dx**2\n", + " # Create the implicit operator of the system.\n", + " A = lhs_operator(len(T0) - 2, sigma)\n", + " # Integrate in time.\n", + " T = T0.copy()\n", + " for n in range(nt):\n", + " # Generate the right-hand side of the system.\n", + " b = rhs_vector(T, sigma, q * dx)\n", + " # Solve the system with scipy.linalg.solve.\n", + " T[1:-1] = linalg.solve(A, b)\n", + " # Apply the Neumann boundary condition.\n", + " T[-1] = T[-2] + q * dx\n", + " return T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We solve the linear system for every time step, but the $A$ matrix does not change. Thus, you can generate it only once and then use it for all time steps. Let's try this out!" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the time-step size based on CFL limit.\n", + "sigma = 0.5\n", + "dt = sigma * dx**2 / alpha # time-step size\n", + "nt = 1000 # number of time steps to compute\n", + "\n", + "# Compute the temperature along the rod.\n", + "T = btcs_implicit(T0, nt, dt, dx, alpha, q)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now plot the solution!" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the temperature along the rod.\n", + "pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel('Distance [m]')\n", + "pyplot.ylabel('Temperature [C]')\n", + "pyplot.grid()\n", + "pyplot.plot(x, T, color='C0', linestyle='-', linewidth=2)\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 100.0);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Not too impressive, this looks just like the result from *explicit* forward in time, centered in space for $\\alpha\\frac{\\Delta t}{\\Delta x^2} = \\frac{1}{2}$. \n", + "\n", + "But try $\\alpha\\frac{\\Delta t}{\\Delta x^2} = 5$, which violates the stability condition of the *explicit* scheme:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Increase the CFL number.\n", + "sigma = 5.0\n", + "dt = sigma * dx**2 / alpha # time-step size\n", + "nt = 100 # number of time steps to compute\n", + "\n", + "# Compute the temperature along the rod.\n", + "T = btcs_implicit(T0, nt, dt, dx, alpha, q)\n", + "\n", + "# Plot the temperature along the rod.\n", + "pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel('Distance [m]')\n", + "pyplot.ylabel('Temperature [C]')\n", + "pyplot.grid()\n", + "pyplot.plot(x, T, color='C0', linestyle='-', linewidth=2)\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 100.0);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**It didn't blow up!**\n", + "\n", + "We were not able to use such a large time step with the explicit scheme. You can try out other values of `sigma` and you'll get a stable solution. In fact, this is an *unconditionally stable* scheme—the most valuable feature of implicit methods is that they give stable solutions without a constraint on the choice of time step. \n", + "\n", + "Using the implicit scheme, we can always advance in time using larger time steps. But each time step requires the solution of a linear system, which is computationally expensive. This is the trade-off between explicit and implicit methods. \n", + "To experiment further, set different values of the Neumann boundary flux and see if the solution behaves as you expect." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### A word of warning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Implicit methods allow you to use significantly larger time steps, because they are not subject to stability constraints. But that doesn't mean you can use just _any_ large time step! Remember that Euler's method is a first-order method, so the _accuracy_ gets worse as you increase the time step, in direct proportion. In fact, you can lose the ability to capture the correct physics if your time step is too large. Numerical stability does not imply accuracy!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Dig deeper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You see how matrix `A` is mostly full of zeros? We call such a matrix *sparse*, and there are many ways to make more efficient calculations taking advantage of their particular structure. First of all, you can optimize the memory usage. Check out SciPy's [sparse-matrix storage formats](https://docs.scipy.org/doc/scipy/reference/sparse.html): you don't need too store $(N-2)^2$ elements! For example, a `coo_matrix` format stores only $3*N_\\text{nonzero}$, where $N_\\text{nonzero}$ is the number of non-zero elements in `A`. Make sure to explore this topic a little more. It's an important topic in numerical PDEs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "###### The cell below loads the style of the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/04_spreadout/04_03_Heat_Equation_2D_Explicit.ipynb b/2-finite-difference-method/lessons/04_spreadout/04_03_Heat_Equation_2D_Explicit.ipynb new file mode 100644 index 0000000..0bc4b13 --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/04_03_Heat_Equation_2D_Explicit.ipynb @@ -0,0 +1,723 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth, C.D. Cooper." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Spreading out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome back! This is the third lesson of the course [Module 4](https://github.com/numerical-mooc/numerical-mooc/tree/master/lessons/04_spreadout), _Spreading out: parabolic PDEs,_ where we study the numerical solution of diffusion problems.\n", + "\n", + "In the first two notebooks, we looked at the 1D heat equation, and solved it numerically using [*explicit*](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_01_Heat_Equation_1D_Explicit.ipynb) and [*implicit*](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_02_Heat_Equation_1D_Implicit.ipynb) schemes. We learned that implicit schemes are unconditionally stable, and we are free to choose any time step. —Wait: _any time step?_ Remember, we still want to capture the physics of the problem accurately. So although stability concerns do not limit the time step, it still has to be small enough to satisfy any accuracy concerns.\n", + "\n", + "We are now ready to graduate to two dimensions! In the remaining lessons of this course module, we will study the 2D heat equation and reaction-diffusion equation. Like before, we start with explicit methods (this lesson) and then move to implicit methods (next lesson). Let's get started." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2D Heat conduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The equation of heat conduction in 2D is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\rho c_p \\frac{\\partial T}{\\partial t} = \\frac{\\partial}{\\partial x} \\left( \\kappa_x \\frac{\\partial T}{\\partial x} \\right) + \\frac{\\partial}{\\partial y} \\left(\\kappa_y \\frac{\\partial T}{\\partial y} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $\\rho$ is the density, $c_p$ is the heat capacity and $\\kappa$ is the thermal conductivity.\n", + "\n", + "If the thermal conductivity $\\kappa$ is constant, then we can take it outside of the spatial derivative and the equation simplifies to:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial T}{\\partial t} = \\alpha \\left(\\frac{\\partial^2 T}{\\partial x^2} + \\frac{\\partial^2 T}{\\partial y^2} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $\\alpha = \\frac{\\kappa}{\\rho c_p}$ is the thermal diffusivity. The thermal diffusivity describes the ability of a material to conduct heat vs. storing it.\n", + "\n", + "Does that equation have a familiar look to it? That's because it's the same as the diffusion equation. There's a reason that $\\alpha$ is called the thermal *diffusivity*! We're going to set up an interesting problem where 2D heat conduction is important, and set about to solve it with explicit finite-difference methods." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem statement" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Removing heat out of micro-chips is a big problem in the computer industry. We are at a point in technology where computers can't run much faster because the chips might start failing due to the high temperature. This is a big deal! Let's study the problem more closely.\n", + "\n", + "We want to understand how heat is dissipated from the chip with a very simplified model. Say we consider the chip as a 2D plate of size $1{\\rm cm}\\times 1{\\rm cm}$, made of Silicon: $\\kappa = 159{\\rm W/m C}$, $c_p = 0.712\\cdot 10^3 {\\rm J/kg C}$, $\\rho = 2329{\\rm kg/m}^3$, and diffusivity $\\alpha \\approx 10^{-4}{\\rm m}^2{/\\rm s}$. Silicon melts at $1414{\\rm C}$, but chips should of course operate at much smaller temperatures. The maximum temperature allowed depends on the processor make and model; in many cases, the maximum temperature is somewhere between $60{\\rm C}$ and $\\sim70{\\rm C}$, but better CPUs are recommended to operate at a [maximum of $80{\\rm C}$](http://www.pugetsystems.com/blog/2009/02/26/intel-core-i7-temperatures/) (like the Intel Core i7, for example).\n", + "\n", + "We're going to set up a somewhat artificial problem, just to demonstrate an interesting numerical solution. Say the chip is in a position where on two edges (top and right) it is in contact with insulating material. On the other two edges the chip is touching other components that have a constant temperature of $T=100{\\rm C}$ when the machine is operating. Initially, the chip is at room temperature $(20{\\rm C})$. *How long does it take for the center of the chip to reach $70{\\rm C}$?*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "#### Figure 1: Simplified microchip problem setup." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's use what we have learned to tackle this problem!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2D Finite differences" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Everything you learned about finite-difference schemes in [Notebook 1 of Module 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_01_1DConvection.ipynb) still applies, but now there are two spatial dimensions. We will need to build a 2D grid of discrete points to compute the solution on. \n", + "\n", + "We will use a 2D Cartesian grid: one that consists of two families of (grid) lines parallel to the two spatial directions. Two lines (of different families) intersect on one and only one grid node (this is called a _structured_ grid). In the $x$ direction, the discretization uses $i=0, \\cdots N_x$ lines, and in the $y$ direction we have $j=0, \\cdots N_y$ lines. A given node on the grid will now have two spatial coordinates, and we need two indices: for the two lines that intersect at that node. For example, the middle point in the figure below would be $T_{i,j}$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "#### Figure 2. Nodal coordinates in 2 dimensions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Explicit scheme in 2D" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recall from above that the 2D heat equation is \n", + "\n", + "$$\n", + "\\frac{\\partial T}{\\partial t} = \\alpha \\left(\\frac{\\partial^2 T}{\\partial x^2} + \\frac{\\partial^2 T}{\\partial y^2} \\right)\n", + "$$\n", + "\n", + "Let's write this out discretized using forward difference in time, and central difference in space, using an explicit scheme. You should be able write this out yourself, without looking—if you need to look, it means you still need to write more difference equations by your own hand!\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{T^{n+1}_{i,j} - T^n_{i,j}}{\\Delta t} = \\alpha \\left( \\frac{T^n_{i+1, j} - 2T^n_{i,j} + T^n_{i-1,j}}{\\Delta x^2} + \\frac{T^n_{i, j+1} - 2T^n_{i,j} + T^n_{i,j-1}}{\\Delta y^2}\\right)\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rearranging the equation to solve for the value at the next time step, $T^{n+1}_{i,j}$, yields\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "T^{n+1}_{i,j}= T^n_{i,j} + \\alpha \\left( \\frac{\\Delta t}{\\Delta x^2} (T^n_{i+1, j} - 2T^n_{i,j} + T^n_{i-1,j}) + \\\\\\frac{\\Delta t}{\\Delta y^2} (T^n_{i, j+1} - 2T^n_{i,j} + T^n_{i,j-1})\\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "That's a little messier than 1D, but still recognizable. \n", + "\n", + "Up until now, we've used stencils to help visualize how a scheme will advance the solution for one time step. Stencils in 2D are a little harder to draw, but hopefully the figure below will guide your understanding of this method: we are using five grid points at time step $n$ to obtain the solution on one point at time step $n+1$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "#### Figure 3: 2D Explicit Stencil" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similar to all of the 1D explicit methods we've used, the solution at $T^{n+1}_{i,j}$ is updated using only known values from the current solution at time $n$. This is straightforward to implement in code, but will be subject to stability limitations on the time step that you can choose. We'll study an implicit method in the next lesson." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Boundary Conditions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Whenever we reach a point that interacts with the boundary, we apply the boundary condition. As in the previous notebook, if the boundary has Dirichlet conditions, we simply impose the prescribed temperature at that point. If the boundary has Neumann conditions, we approximate them with a finite-difference scheme.\n", + "\n", + "Remember, Neumann boundary conditions prescribe the derivative in the normal direction. For example, in the problem described above, we have $\\frac{\\partial T}{\\partial y} = q_y$ in the top boundary and $\\frac{\\partial T}{\\partial x} = q_x$ in the right boundary, with $q_y = q_x = 0$ (insulation).\n", + "\n", + "Thus, at every time step, we need to enforce\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "T_{i,end} = q_y\\cdot\\Delta y + T_{i,end-1}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "and\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "T_{end,j} = q_x\\cdot\\Delta x + T_{end-1,j}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Write the finite-difference discretization of the boundary conditions yourself, and confirm that you can get the expressions above." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Stability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before doing any coding, let's revisit stability constraints. We saw in the first notebook of this series that the 1D explicit discretization of the diffusion equation was stable as long as $\\alpha \\frac{\\Delta t}{(\\Delta x)^2} \\leq \\frac{1}{2}$. In 2D, this constraint is even tighter, as we need to add them in both directions:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\alpha \\frac{\\Delta t}{(\\Delta x)^2} + \\alpha \\frac{\\Delta t}{(\\Delta y)^2} < \\frac{1}{2}.\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Say that the mesh has the same spacing in $x$ and $y$, $\\Delta x = \\Delta y = \\delta$. In that case, the stability condition is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\alpha \\frac{\\Delta t}{\\delta^2} < \\frac{1}{4}\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Code implementation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Array storage" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The physical problem has two dimensions, so we also store the temperatures in two dimensions: in a 2D array. \n", + "\n", + "We chose to store it with the $y$ coordinates corresponding to the rows of the array and $x$ coordinates varying with the columns (this is just a code design decision!). If we are consistent with the stencil formula (with $x$ corresponding to index $i$ and $y$ to index $j$), then $T_{i,j}$ will be stored in array format as `T[j,i]`.\n", + "\n", + "This might be a little confusing as most of us are used to writing coordinates in the format $(x,y)$, but our preference is to have the data stored so that it matches the physical orientation of the problem. Then, when we make a plot of the solution, the visualization will make sense to us, with respect to the geometry of our set-up. That's just nicer than to have the plot rotated!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "#### Figure 4: Row-column data storage" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see on Figure 4 above, if we want to access the value $18$ we would write those coordinates as $(x_2, y_3)$. You can also see that its location is the 3rd row, 2nd column, so its array address would be `T[3,2]`.\n", + "\n", + "Again, this is a design decision. However you can choose to manipulate and store your data however you like; just remember to be consistent!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Code time!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, to some coding! First, we have a little function that will advance the solution in time with a forward-time, centered-space scheme, and will monitor the center of the plate to tell us when it reaches $70{\\rm C}$. Let's start by setting up our Python compute environment." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def ftcs(T0, nt, dt, dx, dy, alpha):\n", + " \"\"\"\n", + " Computes and returns the temperature distribution\n", + " after a given number of time steps.\n", + " Explicit integration using forward differencing\n", + " in time and central differencing in space, with\n", + " Neumann conditions (zero-gradient) on top and right\n", + " boundaries and Dirichlet conditions on bottom and\n", + " left boundaries.\n", + " \n", + " Parameters\n", + " ----------\n", + " T0 : numpy.ndarray\n", + " The initial temperature distribution as a 2D array of floats.\n", + " nt : integer\n", + " Maximum number of time steps to compute.\n", + " dt : float\n", + " Time-step size.\n", + " dx : float\n", + " Grid spacing in the x direction.\n", + " dy : float\n", + " Grid spacing in the y direction.\n", + " alpha : float\n", + " Thermal diffusivity.\n", + " \n", + " Returns\n", + " -------\n", + " T : numpy.ndarray\n", + " The temperature distribution as a 2D array of floats.\n", + " \"\"\"\n", + " # Define some constants.\n", + " sigma_x = alpha * dt / dx**2\n", + " sigma_y = alpha * dt / dy**2\n", + " # Integrate in time.\n", + " T = T0.copy()\n", + " ny, nx = T.shape\n", + " I, J = int(nx / 2), int(ny / 2) # indices of the center\n", + " for n in range(nt):\n", + " T[1:-1, 1:-1] = (T[1:-1, 1:-1] +\n", + " sigma_x * (T[1:-1, 2:] - 2.0 * T[1:-1, 1:-1] + T[1:-1, :-2]) +\n", + " sigma_y * (T[2:, 1:-1] - 2.0 * T[1:-1, 1:-1] + T[:-2, 1:-1]))\n", + " # Apply Neumann conditions (zero-gradient).\n", + " T[-1, :] = T[-2, :]\n", + " T[:, -1] = T[:, -2]\n", + " # Check if the center of the domain has reached T = 70C.\n", + " if T[J, I] >= 70.0:\n", + " break\n", + " print('[time step {}] Center at T={:.2f} at t={:.2f} s'\n", + " .format(n + 1, T[J, I], (n + 1) * dt))\n", + " return T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "See the [`break`](https://docs.python.org/3/tutorial/controlflow.html) statement? It exits the `for` loop at the closest time iteration when the plate reaches $70{\\rm C}$.\n", + "\n", + "In the code cell below, we define our initial conditions according to the problem set up, and choose the discretization parameters. We start with only 20 spatial steps in each coordinate direction and advance for 500 time steps. You should later experiments with these parameters at your leisure!" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "Lx = 0.01 # length of the plate in the x direction\n", + "Ly = 0.01 # height of the plate in the y direction\n", + "nx = 21 # number of points in the x direction\n", + "ny = 21 # number of points in the y direction\n", + "dx = Lx / (nx - 1) # grid spacing in the x direction\n", + "dy = Ly / (ny - 1) # grid spacing in the y direction\n", + "alpha = 1e-4 # thermal diffusivity of the plate\n", + "\n", + "# Define the locations along a gridline.\n", + "x = numpy.linspace(0.0, Lx, num=nx)\n", + "y = numpy.linspace(0.0, Ly, num=ny)\n", + "\n", + "# Compute the initial temperature distribution.\n", + "Tb = 100.0 # temperature at the left and bottom boundaries\n", + "T0 = 20.0 * numpy.ones((ny, nx))\n", + "T0[0, :] = Tb\n", + "T0[:, 0] = Tb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We don't want our solution blowing up, so let's find a time step with $\\frac{\\alpha \\Delta t}{\\Delta x^2} = \\frac{\\alpha \\Delta t}{\\Delta y^2} = \\frac{1}{4}$. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[time step 256] Center at T=70.02 at t=0.16 s\n" + ] + } + ], + "source": [ + "# Set the time-step size based on CFL limit.\n", + "sigma = 0.25\n", + "dt = sigma * min(dx, dy)**2 / alpha # time-step size\n", + "nt = 500 # number of time steps to compute\n", + "\n", + "# Compute the temperature along the rod.\n", + "T = ftcs(T0, nt, dt, dx, dy, alpha)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By now, you're no doubt *very* familiar with the `pyplot.plot` command. It's great for line plots, scatter plots, etc., but what about when we have two spatial dimensions and another value (temperature) to display? \n", + "\n", + "Are you thinking contour plot? We're thinking contour plot. Check out the documentation on [`pyplot.contourf`](http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.contour) (the 'f' denotes \"filled\" contours).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the filled contour of the temperature.\n", + "pyplot.figure(figsize=(8.0, 5.0))\n", + "pyplot.xlabel('x [m]')\n", + "pyplot.ylabel('y [m]')\n", + "levels = numpy.linspace(20.0, 100.0, num=51)\n", + "contf = pyplot.contourf(x, y, T, levels=levels)\n", + "cbar = pyplot.colorbar(contf)\n", + "cbar.set_label('Temperature [C]')\n", + "pyplot.axis('scaled', adjustable='box');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That looks pretty cool! Note that in the call to `pyplot.contourf` you can specify the number of contour levels to display (we chose `51`). Look at that visualization: does it make physical sense to you, considering that the upper and right sides of the chip are insulated, in our problem?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Dig deeper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the problem we just demonstrated, the chip reaches a temperature of $70{\\rm C}$ at a given time, but will it keep increasing? That spells trouble.\n", + "\n", + "Imagine that you have a heat sink instead of an insulator acting on the upper and right sides. What should be the heat flux that the heat sink achieves there, so that the temperature does not exceed $70{\\rm C}$ at the center of the chip?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "###### The cell below loads the style of the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/04_spreadout/04_04_Heat_Equation_2D_Implicit.ipynb b/2-finite-difference-method/lessons/04_spreadout/04_04_Heat_Equation_2D_Implicit.ipynb new file mode 100644 index 0000000..48748f1 --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/04_04_Heat_Equation_2D_Implicit.ipynb @@ -0,0 +1,1033 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth, C.D. Cooper." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Spreading out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We're back! This is the fourth notebook of _Spreading out: parabolic PDEs,_ Module 4 of the course [**\"Practical Numerical Methods with Python\"**](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about). \n", + "\n", + "In the [previous notebook](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_03_Heat_Equation_2D_Explicit.ipynb), we solved a 2D problem for the first time, using an explicit scheme. We know explicit schemes have stability constraints that might make them impractical in some cases, due to requiring a very small time step. Implicit schemes are unconditionally stable, offering the advantage of larger time steps; in [notebook 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_02_Heat_Equation_1D_Implicit.ipynb), we look at the 1D implicit solution of diffusion. Already, that was quite a lot of work: setting up a matrix of coefficients and a right-hand-side vector, while taking care of the boundary conditions, and then solving the linear system. And now, we want to do implicit schemes in 2D—are you ready for this challenge?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2D Heat conduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We already studied 2D heat conduction in the previous lesson, but now we want to work out how to build an implicit solution scheme. To refresh your memory, here is the heat equation again:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial T}{\\partial t} = \\alpha \\left(\\frac{\\partial^2 T}{\\partial x^2} + \\frac{\\partial^2 T}{\\partial y^2} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Our previous solution used a Dirichlet boundary condition on the left and bottom boundaries, with $T(x=0)=T(y=0)=100$, and a Neumann boundary condition with zero flux on the top and right edges, with $q_x=q_y=0$.\n", + "\n", + "$$\n", + "\\left( \\left.\\frac{\\partial T}{\\partial y}\\right|_{y=0.1} = q_y \\right) \\quad \\text{and} \\quad \\left( \\left.\\frac{\\partial T}{\\partial x}\\right|_{x=0.1} = q_x \\right)\n", + "$$\n", + "\n", + "Figure 1 shows a sketch of the problem set up for our hypothetical computer chip with two hot edges and two insulated edges." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Figure 1: Simplified microchip problem setup." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Implicit schemes in 2D" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An implicit discretization will evaluate the spatial derivatives at the next time level, $t^{n+1}$, using the unknown values of the solution variable. For the 2D heat equation with central difference in space, that is written as:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " & \\frac{T^{n+1}_{i,j} - T^n_{i,j}}{\\Delta t} = \\\\\n", + " & \\quad \\alpha \\left( \\frac{T^{n+1}_{i+1, j} - 2T^{n+1}_{i,j} + T^{n+1}_{i-1,j}}{\\Delta x^2} + \\frac{T^{n+1}_{i, j+1} - 2T^{n+1}_{i,j} + T^{n+1}_{i,j-1}}{\\Delta y^2} \\right) \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This equation looks better when we put what we *don't know* on the left and what we *do know* on the right. Make sure to work this out yourself on a piece of paper.\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " & -\\frac{\\alpha \\Delta t}{\\Delta x^2} \\left( T^{n+1}_{i-1,j} + T^{n+1}_{i+1,j} \\right) + \\left( 1 + 2 \\frac{\\alpha \\Delta t}{\\Delta x^2} + 2 \\frac{\\alpha \\Delta t}{\\Delta y^2} \\right) T^{n+1}_{i,j} \\\\\n", + "& \\quad \\quad \\quad -\\frac{\\alpha \\Delta t}{\\Delta y^2} \\left( T^{n+1}_{i,j-1} + T^{n+1}_{i,j+1} \\right) = T^n_{i,j} \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "To make this discussion easier, let's assume that the mesh spacing is the same in both directions and $\\Delta x=\\Delta y = \\delta$:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "-T^{n+1}_{i-1,j} - T^{n+1}_{i+1,j} + \\left(\\frac{\\delta^2}{\\alpha \\Delta t} + 4 \\right) T^{n+1}_{i,j} - T^{n+1}_{i,j-1}-T^{n+1}_{i,j+1} = \\frac{\\delta^2}{\\alpha \\Delta t}T^n_{i,j}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Just like in the one-dimensional case, $T_{i,j}$ appears in the equation for $T_{i-1,j}$, $T_{i+1,j}$, $T_{i,j+1}$ and $T_{i,j-1}$, and we can form a linear system to advance in time. But, how do we construct the matrix in this case? What are the $(i+1,j)$, $(i-1,j)$, $(i,j+1)$, and $(i,j-1)$ positions in the matrix?\n", + "\n", + "With explicit schemes we don't need to worry about these things. We can lay out the data just as it is in the physical problem. We had an array `T` that was a 2-dimensional matrix. To fetch the temperature in the next node in the $x$ direction $(T_{i+1,j})$ we just did `T[j,i+1]`, and likewise in the $y$ direction $(T_{i,j+1})$ was in `T[j+1,i]`. In implicit schemes, we need to think a bit harder about how the data is mapped to the physical problem.\n", + "\n", + "Also, remember from the [notebook on 1D-implicit schemes](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_02_Heat_Equation_1D_Implicit.ipynb) that the linear system had $N-2$ elements? We applied boundary conditions on nodes $i=0$ and $i=N-1$, and they were not modified by the linear system. In 2D, this becomes a bit more complicated.\n", + "\n", + "Let's use Figure 1, representing a set of grid nodes in two dimensions, to guide the discussion." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Figure 2: Layout of matrix elements in 2D problem" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Say we have the 2D domain of size $L_x\\times L_y$ discretized in $n_x$ and $n_y$ points. We can divide the nodes into boundary nodes (empty circles) and interior nodes (filled circles).\n", + "\n", + "The boundary nodes, as the name says, are on the boundary. They are the nodes with indices $(i=0,j)$, $(i=n_x-1,j)$, $(i,j=0)$, and $(i,j=n_y-1)$, and boundary conditions are enforced there.\n", + "\n", + "The interior nodes are not on the boundary, and the finite-difference equation acts on them. If we leave the boundary nodes aside for the moment, then the grid will have $(n_x-2)\\cdot(n_y-2)$ nodes that need to be updated on each time step. This is the number of unknowns in the linear system. The matrix of coefficients will have $\\left( (n_x-2)\\cdot(n_y-2) \\right)^2$ elements (most of them zero!).\n", + "\n", + "To construct the matrix, we will iterate over the nodes in an x-major order: index $i$ will run faster. The order will be \n", + "\n", + "* $(i=1,j=1)$\n", + "* $(i=2,j=1)$ ...\n", + "* $(i=nx-2,j=1)$\n", + "* $(i=1,j=2)$\n", + "* $(i=2,j=2)$ ... \n", + "* $(i=n_x-2,j=n_y-2)$. \n", + "\n", + "That is the ordering represented by dotted line on Figure 1. Of course, if you prefer to organize the nodes differently, feel free to do so!\n", + "\n", + "Because we chose this ordering, the equation for nodes $(i-1,j)$ and $(i+1,j)$ will be just before and after $(i,j)$, respectively. But what about $(i,j-1)$ and $(i,j+1)$? Even though in the physical problem they are very close, the equations are $n_x-2$ places apart! This can tie your head in knots pretty quickly. \n", + "\n", + "_The only way to truly understand it is to make your own diagrams and annotations on a piece of paper and reconstruct this argument!_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Boundary conditions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before we attempt to build the matrix, we need to think about boundary conditions. There is some bookkeeping to be done here, so bear with us for a moment.\n", + "\n", + "Say, for example, that the left and bottom boundaries have Dirichlet boundary conditions, and the top and right boundaries have Neumann boundary conditions.\n", + "\n", + "Let's look at each case:\n", + "\n", + "**Bottom boundary:**\n", + " \n", + "The equation for $j=1$ (interior points adjacent to the bottom boundary) uses values from $j=0$, which are known. Let's put that on the right-hand side of the equation. We get this equation for all points across the $x$-axis that are adjacent to the bottom boundary:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " -T^{n+1}_{i-1,1} - T^{n+1}_{i+1,1} + \\left( \\frac{\\delta^2}{\\alpha \\Delta t} + 4 \\right) T^{n+1}_{i,1} - T^{n+1}_{i,j+1} \\qquad & \\\\\n", + " = \\frac{\\delta^2}{\\alpha \\Delta t} T^n_{i,1} + T^{n+1}_{i,0} & \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "**Left boundary:**\n", + "\n", + "Like for the bottom boundary, the equation for $i=1$ (interior points adjacent to the left boundary) uses known values from $i=0$, and we will put that on the right-hand side:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " -T^{n+1}_{2,j} + \\left( \\frac{\\delta^2}{\\alpha \\Delta t} + 4 \\right) T^{n+1}_{1,j} - T^{n+1}_{1,j-1} - T^{n+1}_{1,j+1} \\qquad & \\\\\n", + " = \\frac{\\delta^2}{\\alpha \\Delta t} T^n_{1,j} + T^{n+1}_{0,j} & \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "**Right boundary:**\n", + "\n", + "Say the boundary condition is $\\left. \\frac{\\partial T}{\\partial x} \\right|_{x=L_x} = q_x$. Its finite-difference approximation is\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\frac{T^{n+1}_{n_x-1,j} - T^{n+1}_{n_x-2,j}}{\\delta} = q_x\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We can write $T^{n+1}_{n_x-1,j} = \\delta q_x + T^{n+1}_{n_x-2,j}$ to get the finite difference equation for $i=n_x-2$:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " -T^{n+1}_{n_x-3,j} + \\left( \\frac{\\delta^2}{\\alpha \\Delta t} + 3 \\right) T^{n+1}_{n_x-2,j} - T^{n+1}_{n_x-2,j-1} - T^{n+1}_{n_x-2,j+1} \\qquad & \\\\\n", + " = \\frac{\\delta^2}{\\alpha \\Delta t} T^n_{n_x-2,j} + \\delta q_x & \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Not sure about this? Grab pen and paper! _Please_, check this yourself. It will help you understand!\n", + "\n", + "**Top boundary:**\n", + "\n", + "Neumann boundary conditions specify the derivative normal to the boundary: $\\left. \\frac{\\partial T}{\\partial y} \\right|_{y=L_y} = q_y$. No need to repeat what we did for the right boundary, right? The equation for $j=n_y-2$ is\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " -T^{n+1}_{i-1,n_y-2} - T^{n+1}_{i+1,n_y-2} + \\left( \\frac{\\delta^2}{\\alpha \\Delta t} + 3 \\right) T^{n+1}_{i,n_y-2} - T^{n+1}_{i,n_y-3} \\qquad & \\\\\n", + " = \\frac{\\delta^2}{\\alpha \\Delta t} T^n_{i,n_y-2} + \\delta q_y & \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "So far, we have then 5 possible cases: bottom, left, right, top, and interior points. Does this cover everything? What about corners?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Bottom-left corner**\n", + "\n", + "At $T_{1,1}$ there is a Dirichlet boundary condition at $i=0$ and $j=0$. This equation is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " -T^{n+1}_{2,1} + \\left( \\frac{\\delta^2}{\\alpha \\Delta t} + 4 \\right) T^{n+1}_{1,1} - T^{n+1}_{1,2} \\qquad & \\\\\n", + " = \\frac{\\delta^2}{\\alpha \\Delta t} T^n_{1,1} + T^{n+1}_{0,1} + T^{n+1}_{1,0} & \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "**Top-left corner:**\n", + "\n", + "At $T_{1,n_y-2}$ there is a Dirichlet boundary condition at $i=0$ and a Neumann boundary condition at $i=n_y-1$. This equation is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " -T^{n+1}_{2,n_y-2} + \\left( \\frac{\\delta^2}{\\alpha \\Delta t} + 3 \\right) T^{n+1}_{1,n_y-2} - T^{n+1}_{1,n_y-3} \\qquad & \\\\\n", + " = \\frac{\\delta^2}{\\alpha \\Delta t} T^n_{1,n_y-2} + T^{n+1}_{0,n_y-2} + \\delta q_y & \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "**Top-right corner**\n", + "\n", + "At $T_{n_x-2,n_y-2}$, there are Neumann boundary conditions at both $i=n_x-1$ and $j=n_y-1$. The finite difference equation is then\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " -T^{n+1}_{n_x-3,n_y-2} + \\left( \\frac{\\delta^2}{\\alpha \\Delta t} + 2 \\right) T^{n+1}_{n_x-2,n_y-2} - T^{n+1}_{n_x-2,n_y-3} \\qquad & \\\\\n", + " = \\frac{\\delta^2}{\\alpha \\Delta t} T^n_{n_x-2,n_y-2} + \\delta(q_x + q_y) & \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "**Bottom-right corner**\n", + "\n", + "To calculate $T_{n_x-2,1}$ we need to consider a Dirichlet boundary condition to the bottom and a Neumann boundary condition to the right. We will get a similar equation to the top-left corner!\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " -T^{n+1}_{n_x-3,1} + \\left( \\frac{\\delta^2}{\\alpha \\Delta t} + 3 \\right) T^{n+1}_{n_x-2,1} - T^{n+1}_{n_x-2,2} \\qquad & \\\\\n", + " = \\frac{\\delta^2}{\\alpha \\Delta t} T^n_{n_x-2,1} + T^{n+1}_{n_x-2,0} + \\delta q_x & \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Okay, now we are actually ready. We have checked every possible case!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The linear system" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Like in the previous lesson introducing implicit schemes, we will solve a linear system at every time step:\n", + "\n", + "$$\n", + "[A][T^{n+1}_\\text{int}] = [b]+[b]_{b.c.}\n", + "$$\n", + "\n", + "The coefficient matrix now takes some more work to figure out and to build in code. There is no substitute for you working this out patiently on paper!\n", + "\n", + "The structure of the matrix can be described as a series of diagonal blocks, and lots of zeros elsewhere. Look at Figure 3, representing the block structure of the coefficient matrix, and refer back to Figure 2, showing the discretization grid in physical space. The first row of interior points, adjacent to the bottom boundary, generates the matrix block labeled $A_1$. The top row of interior points, adjacent to the top boundary generates the matrix block labeled $A_3$. All other interior points in the grid generate similar blocks, labeled $A_2$ on Figure 3." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Figure 3: Sketch of coefficient-matrix blocks." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Figure 4: Grid points corresponding to each matrix-block type." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The matrix block $A_1$ is\n", + "\n", + "\n", + "\n", + "The block matrix $A_2$ is\n", + "\n", + "\n", + "\n", + "The block matrix $A_3$ is\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vector $T^{n+1}_\\text{int}$ contains the temperature of the interior nodes in the next time step. It is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "T^{n+1}_\\text{int} = \\left[\n", + "\\begin{array}{c}\n", + "T^{n+1}_{1,1}\\\\\n", + "T^{n+1}_{2,1} \\\\\n", + "\\vdots \\\\\n", + "T^{n+1}_{n_x-2,1} \\\\\n", + "T^{n+1}_{2,1} \\\\\n", + "\\vdots \\\\\n", + "T^{n+1}_{n_x-2,n_y-2}\n", + "\\end{array}\n", + "\\right]\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Remember the x-major ordering we chose!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, the right-hand side is\n", + "\\begin{equation}\n", + "[b]+[b]_{b.c.} = \n", + "\\left[\\begin{array}{c}\n", + "\\sigma^\\prime T^n_{1,1} + T^{n+1}_{0,1} + T^{n+1}_{1,0} \\\\\n", + "\\sigma^\\prime T^n_{2,0} + T^{n+1}_{2,0} \\\\\n", + "\\vdots \\\\\n", + "\\sigma^\\prime T^n_{n_x-2,1} + T^{n+1}_{n_x-2,0} + \\delta q_x \\\\\n", + "\\sigma^\\prime T^n_{1,2} + T^{n+1}_{0,2} \\\\\n", + "\\vdots \\\\\n", + "\\sigma^\\prime T^n_{n_x-2,n_y-2} + \\delta(q_x + q_y)\n", + "\\end{array}\\right]\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "where $\\sigma^\\prime = 1/\\sigma = \\delta^2/\\alpha \\Delta t$. The matrix looks very ugly, but it is important you understand it! Think about it. Can you answer:\n", + " * Why a -1 factor appears $n_x-2$ columns after the diagonal? What about $n_x-2$ columns before the diagonal?\n", + " * Why in row $n_x-2$ the position after the diagonal contains a 0?\n", + " * Why in row $n_x-2$ the diagonal is $\\sigma^\\prime + 3$ rather than $\\sigma^\\prime + 4$?\n", + " * Why in the last row the diagonal is $\\sigma^\\prime + 2$ rather than $\\sigma^\\prime + 4$?\n", + " \n", + "If you can answer those questions, you are in good shape to continue!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's write a function that will generate the matrix and right-hand side for the heat conduction problem in the previous notebook. Remember, we had Dirichlet boundary conditions in the left and bottom, and zero-flux Neumann boundary condition on the top and right $(q_x=q_y=0)$. \n", + "\n", + "Also, we'll import `scipy.linalg.solve` because we need to solve a linear system." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from scipy import linalg" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def lhs_operator(M, N, sigma):\n", + " \"\"\"\n", + " Assembles and returns the implicit operator\n", + " of the system for the 2D diffusion equation.\n", + " We use a Dirichlet condition at the left and\n", + " bottom boundaries and a Neumann condition\n", + " (zero-gradient) at the right and top boundaries.\n", + " \n", + " Parameters\n", + " ----------\n", + " M : integer\n", + " Number of interior points in the x direction.\n", + " N : integer\n", + " Number of interior points in the y direction.\n", + " sigma : float\n", + " Value of alpha * dt / dx**2.\n", + " \n", + " Returns\n", + " -------\n", + " A : numpy.ndarray\n", + " The implicit operator as a 2D array of floats\n", + " of size M*N by M*N.\n", + " \"\"\"\n", + " A = numpy.zeros((M * N, M * N))\n", + " for j in range(N):\n", + " for i in range(M):\n", + " I = j * M + i # row index\n", + " # Get index of south, west, east, and north points.\n", + " south, west, east, north = I - M, I - 1, I + 1, I + M\n", + " # Setup coefficients at corner points.\n", + " if i == 0 and j == 0: # bottom-left corner\n", + " A[I, I] = 1.0 / sigma + 4.0\n", + " A[I, east] = -1.0\n", + " A[I, north] = -1.0\n", + " elif i == M - 1 and j == 0: # bottom-right corner\n", + " A[I, I] = 1.0 / sigma + 3.0\n", + " A[I, west] = -1.0\n", + " A[I, north] = -1.0\n", + " elif i == 0 and j == N - 1: # top-left corner\n", + " A[I, I] = 1.0 / sigma + 3.0\n", + " A[I, south] = -1.0\n", + " A[I, east] = -1.0\n", + " elif i == M - 1 and j == N - 1: # top-right corner\n", + " A[I, I] = 1.0 / sigma + 2.0\n", + " A[I, south] = -1.0\n", + " A[I, west] = -1.0\n", + " # Setup coefficients at side points (excluding corners).\n", + " elif i == 0: # left side\n", + " A[I, I] = 1.0 / sigma + 4.0\n", + " A[I, south] = -1.0\n", + " A[I, east] = -1.0\n", + " A[I, north] = -1.0\n", + " elif i == M - 1: # right side\n", + " A[I, I] = 1.0 / sigma + 3.0\n", + " A[I, south] = -1.0\n", + " A[I, west] = -1.0\n", + " A[I, north] = -1.0\n", + " elif j == 0: # bottom side\n", + " A[I, I] = 1.0 / sigma + 4.0\n", + " A[I, west] = -1.0\n", + " A[I, east] = -1.0\n", + " A[I, north] = -1.0\n", + " elif j == N - 1: # top side\n", + " A[I, I] = 1.0 / sigma + 3.0\n", + " A[I, south] = -1.0\n", + " A[I, west] = -1.0\n", + " A[I, east] = -1.0\n", + " # Setup coefficients at interior points.\n", + " else:\n", + " A[I, I] = 1.0 / sigma + 4.0\n", + " A[I, south] = -1.0\n", + " A[I, west] = -1.0\n", + " A[I, east] = -1.0\n", + " A[I, north] = -1.0\n", + " return A" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def rhs_vector(T, M, N, sigma, Tb):\n", + " \"\"\"\n", + " Assembles and returns the right-hand side vector\n", + " of the system for the 2D diffusion equation.\n", + " We use a Dirichlet condition at the left and\n", + " bottom boundaries and a Neumann condition\n", + " (zero-gradient) at the right and top boundaries.\n", + " \n", + " Parameters\n", + " ----------\n", + " T : numpy.ndarray\n", + " The temperature distribution as a 1D array of floats.\n", + " M : integer\n", + " Number of interior points in the x direction.\n", + " N : integer\n", + " Number of interior points in the y direction.\n", + " sigma : float\n", + " Value of alpha * dt / dx**2.\n", + " Tb : float\n", + " Boundary value for Dirichlet conditions.\n", + " \n", + " Returns\n", + " -------\n", + " b : numpy.ndarray\n", + " The right-hand side vector as a 1D array of floats\n", + " of size M*N.\n", + " \"\"\"\n", + " b = 1.0 / sigma * T\n", + " # Add Dirichlet term at points located next\n", + " # to the left and bottom boundaries.\n", + " for j in range(N):\n", + " for i in range(M):\n", + " I = j * M + i\n", + " if i == 0:\n", + " b[I] += Tb\n", + " if j == 0:\n", + " b[I] += Tb\n", + " return b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The solution of the linear system $(T^{n+1}_\\text{int})$ contains the temperatures of the interior points at the next time step in a 1D array. We will also create a function that will take the values of $T^{n+1}_\\text{int}$ and put them in a 2D array that resembles the physical domain." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def map_1d_to_2d(T_1d, nx, ny, Tb):\n", + " \"\"\"\n", + " Maps a 1D array of the temperature at the interior points\n", + " to a 2D array that includes the boundary values.\n", + " \n", + " Parameters\n", + " ----------\n", + " T_1d : numpy.ndarray\n", + " The temperature at the interior points as a 1D array of floats.\n", + " nx : integer\n", + " Number of points in the x direction of the domain.\n", + " ny : integer\n", + " Number of points in the y direction of the domain.\n", + " Tb : float\n", + " Boundary value for Dirichlet conditions.\n", + " \n", + " Returns\n", + " -------\n", + " T : numpy.ndarray\n", + " The temperature distribution in the domain\n", + " as a 2D array of size ny by nx.\n", + " \"\"\"\n", + " T = numpy.zeros((ny, nx))\n", + " # Get the value at interior points.\n", + " T[1:-1, 1:-1] = T_1d.reshape((ny - 2, nx - 2))\n", + " # Use Dirichlet condition at left and bottom boundaries.\n", + " T[:, 0] = Tb\n", + " T[0, :] = Tb\n", + " # Use Neumann condition at right and top boundaries.\n", + " T[:, -1] = T[:, -2]\n", + " T[-1, :] = T[-2, :]\n", + " return T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And to advance in time, we will use" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def btcs_implicit_2d(T0, nt, dt, dx, alpha, Tb):\n", + " \"\"\"\n", + " Computes and returns the distribution of the\n", + " temperature after a given number of time steps.\n", + " \n", + " The 2D diffusion equation is integrated using\n", + " Euler implicit in time and central differencing\n", + " in space, with a Dirichlet condition at the left\n", + " and bottom boundaries and a Neumann condition\n", + " (zero-gradient) at the right and top boundaries.\n", + " \n", + " Parameters\n", + " ----------\n", + " T0 : numpy.ndarray\n", + " The initial temperature distribution as a 2D array of floats.\n", + " nt : integer\n", + " Number of time steps to compute.\n", + " dt : float\n", + " Time-step size.\n", + " dx : float\n", + " Grid spacing in the x and y directions.\n", + " alpha : float\n", + " Thermal diffusivity of the plate.\n", + " Tb : float\n", + " Boundary value for Dirichlet conditions.\n", + " \n", + " Returns\n", + " -------\n", + " T : numpy.ndarray\n", + " The temperature distribution as a 2D array of floats.\n", + " \"\"\"\n", + " # Get the number of points in each direction.\n", + " ny, nx = T0.shape\n", + " # Get the number of interior points in each direction.\n", + " M, N = nx - 2, ny - 2\n", + " # Compute the constant sigma.\n", + " sigma = alpha * dt / dx**2\n", + " # Create the implicit operator of the system.\n", + " A = lhs_operator(M, N, sigma)\n", + " # Integrate in time.\n", + " T = T0[1:-1, 1:-1].flatten() # interior points as a 1D array\n", + " I, J = int(M / 2), int(N / 2) # indices of the center\n", + " for n in range(nt):\n", + " # Compute the right-hand side of the system.\n", + " b = rhs_vector(T, M, N, sigma, Tb)\n", + " # Solve the system with scipy.linalg.solve.\n", + " T = linalg.solve(A, b)\n", + " # Check if the center of the domain has reached T = 70C.\n", + " if T[J * M + I] >= 70.0:\n", + " break\n", + " print('[time step {}] Center at T={:.2f} at t={:.2f} s'\n", + " .format(n + 1, T[J * M + I], (n + 1) * dt))\n", + " # Returns the temperature in the domain as a 2D array.\n", + " return map_1d_to_2d(T, nx, ny, Tb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remember, we want the function to tell us when the center of the plate reaches $70^\\circ C$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Dig deeper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For demonstration purposes, these functions are very explicit. But you can see a trend here, right? \n", + "\n", + "Say we start with a matrix with `1/sigma+4` in the main diagonal, and `-1` on the 4 other corresponding diagonals. Now, we have to modify the matrix only where the boundary conditions are affecting. We saw the impact of the Dirichlet and Neumann boundary condition on each position of the matrix, we just need to know in which position to perform those changes. \n", + "\n", + "A function that maps `i` and `j` into `row_number` would be handy, right? How about `row_number = (j-1)*(nx-2)+(i-1)`? By feeding `i` and `j` to that equation, you know exactly where to operate on the matrix. For example, `i=nx-2, j=2`, which is in row `row_number = 2*nx-5`, is next to a Neumann boundary condition: we have to substract one out of the main diagonal (`A[2*nx-5,2*nx-5]-=1`), and put a zero in the next column (`A[2*nx-5,2*nx-4]=0`). This way, the function can become much simpler!\n", + "\n", + "Can you use this information to construct a more general function `lhs_operator`? Can you make it such that the type of boundary condition is an input to the function? " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Heat diffusion in 2D" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's recast the 2D heat conduction from the previous notebook, and solve it with an implicit scheme. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "Lx = 0.01 # length of the plate in the x direction\n", + "Ly = 0.01 # length of the plate in the y direction\n", + "nx = 21 # number of points in the x direction\n", + "ny = 21 # number of points in the y direction\n", + "dx = Lx / (nx - 1) # grid spacing in the x direction\n", + "dy = Ly / (ny - 1) # grid spacing in the y direction\n", + "alpha = 1e-4 # thermal diffusivity\n", + "\n", + "# Define the locations along a gridline.\n", + "x = numpy.linspace(0.0, Lx, num=nx)\n", + "y = numpy.linspace(0.0, Ly, num=ny)\n", + "\n", + "# Compute the initial temperature distribution.\n", + "Tb = 100.0 # temperature at the left and bottom boundaries\n", + "T0 = 20.0 * numpy.ones((ny, nx))\n", + "T0[:, 0] = Tb\n", + "T0[0, :] = Tb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are ready to go!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[time step 257] Center at T=70.00 at t=0.16 s\n" + ] + } + ], + "source": [ + "# Set the time-step size based on CFL limit.\n", + "sigma = 0.25\n", + "dt = sigma * min(dx, dy)**2 / alpha # time-step size\n", + "nt = 300 # number of time steps to compute\n", + "\n", + "# Compute the temperature along the rod.\n", + "T = btcs_implicit_2d(T0, nt, dt, dx, alpha, Tb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And plot," + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the filled contour of the temperature.\n", + "pyplot.figure(figsize=(8.0, 5.0))\n", + "pyplot.xlabel('x [m]')\n", + "pyplot.ylabel('y [m]')\n", + "levels = numpy.linspace(20.0, 100.0, num=51)\n", + "contf = pyplot.contourf(x, y, T, levels=levels)\n", + "cbar = pyplot.colorbar(contf)\n", + "cbar.set_label('Temperature [C]')\n", + "pyplot.axis('scaled', adjustable='box');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Try this out with different values of `sigma`! You'll see that it will always give a stable solution!\n", + "\n", + "Does this result match the explicit scheme from the previous notebook? Do they take the same amount of time to reach $70^\\circ C$ in the center of the plate? Now that we can use higher values of `sigma`, we need fewer time steps for the center of the plate to reach $70^\\circ C$! Of course, we need to be careful that `dt` is small enough to resolve the physics correctly." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "###### The cell below loads the style of the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/04_spreadout/04_05_Crank-Nicolson.ipynb b/2-finite-difference-method/lessons/04_spreadout/04_05_Crank-Nicolson.ipynb new file mode 100644 index 0000000..370470f --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/04_05_Crank-Nicolson.ipynb @@ -0,0 +1,1354 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, C.D. Cooper, G.F. Forsyth." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Spreading out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome to the fifth, and last, notebook of Module 4 \"_Spreading out: diffusion problems,\"_ of our fabulous course **\"Practical Numerical Methods with Python.\"**\n", + "\n", + "In this course module, we have learned about explicit and implicit methods for parabolic equations in 1 and 2 dimensions. So far, all schemes have been first-order in time and second-order in space. _Can we do any better?_ We certainly can: this notebook presents the Crank-Nicolson scheme, which is a second-order method in both time and space! We will continue to use the heat equation to guide the discussion, as we've done throughout this module. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Crank-Nicolson scheme" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The [Crank Nicolson scheme](http://en.wikipedia.org/wiki/Crank–Nicolson_method) is a popular second-order, implicit method used with parabolic PDEs in particular. It was developed by John Crank and [Phyllis Nicolson](http://en.wikipedia.org/wiki/Phyllis_Nicolson). The main idea is to take the average between the solutions at $t^n$ and $t^{n+1}$ in the evaluation of the spatial derivative. Why bother doing that? Because the time derivative will then be discretized with a centered scheme, giving second-order accuracy!\n", + "\n", + "Remember the 1D heat equation from the [first notebook](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_01_Heat_Equation_1D_Explicit.ipynb)? Just to refresh your memory, here it is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\frac{\\partial T}{\\partial t} = \\alpha \\frac{\\partial^2 T}{\\partial x^2}.\n", + "\\end{equation}\n", + "$$\n", + "\n", + "In this case, the Crank-Nicolson scheme leads to the following discretized equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " & \\frac{T^{n+1}_i - T^n_i}{\\Delta t} = \\\\\n", + " & \\quad \\alpha \\cdot \\frac{1}{2} \\left( \\frac{T^{n+1}_{i+1} - 2 T^{n+1}_i + T^{n+1}_{i-1}}{\\Delta x^2} + \\frac{T^n_{i+1} - 2 T^n_i + T^n_{i-1}}{\\Delta x^2} \\right) \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Notice how the both time indices $n$ and $n+1$ appear on the right-hand side. You know we'll have to rearrange this equation, right? Now look at the stencil and notice that we are using more information than before in the update." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![stencil-cranknicolson](./figures/stencil-cranknicolson.png)\n", + "#### Figure 2. Stencil of the Crank-Nicolson scheme." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rearranging terms so that everything that we don't know is on the left side and what we do know on the right side, we get\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " & -T^{n+1}_{i-1} + 2 \\left( \\frac{\\Delta x^2}{\\alpha \\Delta t} + 1 \\right) T^{n+1}_i - T^{n+1}_{i+1} \\\\\n", + " & \\qquad = T^{n}_{i-1} + 2 \\left( \\frac{\\Delta x^2}{\\alpha \\Delta t} - 1 \\right) T^{n}_i + T^{n}_{i+1} \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Again, we are left with a linear system of equations. Check out the left side of that equation: it looks a lot like the matrix from [notebook 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_02_Heat_Equation_1D_Implicit.ipynb), doesn't it? Apart from the slight modification in the $T_i^{n+1}$ term, the left side of the equation is pretty much the same. What about the right-hand side? Sure, it looks quite different, but that is not a problem, we know all those terms!\n", + "\n", + "Things don't change much for boundary conditions, either. We've seen all the cases already. Say $T_0^{n+1}$ is a Dirichlet boundary. Then the equation for $i=1$ becomes\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " & 2 \\left( \\frac{\\Delta x^2}{\\alpha \\Delta t} + 1 \\right) T^{n+1}_1 - T^{n+1}_{2} \\\\ \n", + " & \\qquad = T^{n}_{0} + 2 \\left( \\frac{\\Delta x^2}{\\alpha \\Delta t} - 1 \\right) T^{n}_1 + T^{n}_{2} + T^{n+1}_{0} \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "And if we have a Neumann boundary $\\left(\\left.\\frac{\\partial T}{\\partial x}\\right|_{x=L} = q\\right)$ at $T_{n_x-1}^{n+1}$? We know this stuff, right? For $i=n_x-2$ we get\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " & -T^{n+1}_{n_x-3} + \\left( 2 \\frac{\\Delta x^2}{\\alpha \\Delta t} + 1 \\right) T^{n+1}_{n_x-2} \\\\\n", + " & \\qquad = T^{n}_{n_x-3} + 2 \\left( \\frac{\\Delta x^2}{\\alpha \\Delta t} - 1 \\right) T^{n}_{n_x-2} + T^{n}_{n_x-1} + q\\Delta x \\\\\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The code will look a lot like the implicit method from the [second notebook](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_02_Heat_Equation_1D_Implicit.ipynb). Only some terms of the matrix and right-hand-side vector will be different, which changes some of our custom functions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The linear system" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just like in [notebook 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_02_Heat_Equation_1D_Implicit.ipynb), we need to solve a linear system on every time step of the form:\n", + "\n", + "$$\n", + "[A][T^{n+1}_\\text{int}] = [b]+[b]_{b.c.}\n", + "$$\n", + "\n", + "The coefficient matrix is very similar to the previous case, but the right-hand side changes a lot:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$\n", + "\\begin{align}\n", + " \\left[\n", + " \\begin{array}{cccccc}\n", + " 2 \\left( \\frac{1}{\\sigma} + 1 \\right) & -1 & 0 & \\cdots & & 0 \\\\\n", + " -1 & 2 \\left( \\frac{1}{\\sigma} + 1\\right) & -1 & 0 & \\cdots & 0 \\\\\n", + " 0 & & \\ddots & & & \\vdots \\\\\n", + " \\vdots & & & & 2 \\left( \\frac{1}{\\sigma} + 1\\right) & \\\\\n", + " 0 & \\cdots & & & -1 & \\left( 2 \\frac{1}{\\sigma} + 1\\right) \\\\\n", + " \\end{array}\n", + " \\right] \\cdot \n", + " \\left[\n", + " \\begin{array}{c} \n", + " T_1^{n+1} \\\\\n", + " T_2^{n+1} \\\\\n", + " \\vdots \\\\\n", + " \\\\\n", + " T_{N-2}^{n+1} \\\\\n", + " \\end{array}\n", + " \\right] =\n", + " \\left[\n", + " \\begin{array}{c}\n", + " T_0^n + 2 \\left( \\frac{1}{\\sigma} - 1 \\right) T_1^n + T_2^n \\\\\n", + " T_1^n + 2 \\left( \\frac{1}{\\sigma} - 1 \\right) T_2^n + T_3^n \\\\\n", + " \\vdots \\\\\n", + " \\\\\n", + " T_{n_x-3}^n + 2 \\left( \\frac{1}{\\sigma} - 1 \\right) T_{n_x-2}^n + T_{n_x-1}^n \\\\\n", + " \\end{array}\n", + " \\right] +\n", + " \\begin{bmatrix}\n", + " T_0^{n+1} \\\\\n", + " 0\\\\\n", + " \\vdots \\\\\n", + " 0 \\\\\n", + " q \\Delta x \\\\\n", + " \\end{bmatrix}\n", + "\\end{align}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's write a function that will create the coefficient matrix and right-hand-side vectors for the heat conduction problem from [notebook 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_02_Heat_Equation_1D_Implicit.ipynb): with Dirichlet boundary at $x=0$ and zero-flux boundary $(q=0)$ at $x=L$." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from scipy import linalg" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def lhs_operator(N, sigma):\n", + " \"\"\"\n", + " Computes and returns the implicit operator\n", + " of the system for the 1D diffusion equation.\n", + " We use Crank-Nicolson method, Dirichlet condition\n", + " on the left side of the domain and zero-gradient\n", + " Neumann condition on the right side.\n", + " \n", + " Parameters\n", + " ----------\n", + " N : integer\n", + " Number of interior points.\n", + " sigma : float\n", + " Value of alpha * dt / dx**2.\n", + " \n", + " Returns\n", + " -------\n", + " A : numpy.ndarray\n", + " The implicit operator as a 2D array of floats\n", + " of size N by N.\n", + " \"\"\"\n", + " # Setup the diagonal of the operator.\n", + " D = numpy.diag(2.0 * (1.0 + 1.0 / sigma) * numpy.ones(N))\n", + " # Setup the Neumann condition for the last element.\n", + " D[-1, -1] = 1.0 + 2.0 / sigma\n", + " # Setup the upper diagonal of the operator.\n", + " U = numpy.diag(-1.0 * numpy.ones(N - 1), k=1)\n", + " # Setup the lower diagonal of the operator.\n", + " L = numpy.diag(-1.0 * numpy.ones(N - 1), k=-1)\n", + " # Assemble the operator.\n", + " A = D + U + L\n", + " return A" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def rhs_vector(T, sigma, qdx):\n", + " \"\"\"\n", + " Computes and returns the right-hand side of the system\n", + " for the 1D diffusion equation, using a Dirichlet condition\n", + " on the left side and a Neumann condition on the right side.\n", + " \n", + " Parameters\n", + " ----------\n", + " T : numpy.ndarray\n", + " The temperature distribution as a 1D array of floats.\n", + " sigma : float\n", + " Value of alpha * dt / dx**2.\n", + " qdx : float\n", + " Value of the temperature flux at the right side.\n", + " \n", + " Returns\n", + " -------\n", + " b : numpy.ndarray\n", + " The right-hand side of the system as a 1D array of floats.\n", + " \"\"\"\n", + " b = T[:-2] + 2.0 * (1.0 / sigma - 1.0) * T[1:-1] + T[2:]\n", + " # Set Dirichlet condition.\n", + " b[0] += T[0]\n", + " # Set Neumann condition.\n", + " b[-1] += qdx\n", + " return b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will solve the linear system at every time step. Let's define a function to step in time:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def crank_nicolson(T0, nt, dt, dx, alpha, q):\n", + " \"\"\"\n", + " Computes and returns the temperature along the rod\n", + " after a given number of time steps.\n", + " \n", + " The function uses Crank-Nicolson method in time,\n", + " central differencing in space, a Dirichlet condition\n", + " on the left side, and a Neumann condition on the\n", + " right side.\n", + " \n", + " Parameters\n", + " ----------\n", + " T0 : numpy.ndarray\n", + " The initial temperature distribution as a 1D array of floats.\n", + " nt : integer\n", + " Number of time steps to compute.\n", + " dt : float\n", + " Time-step size.\n", + " dx : float\n", + " Distance between two consecutive locations.\n", + " alpha : float\n", + " Thermal diffusivity of the rod.\n", + " q : float\n", + " Value of the temperature gradient on the right side.\n", + " \n", + " Returns\n", + " -------\n", + " T : numpy.ndarray\n", + " The temperature distribution as a 1D array of floats.\n", + " \"\"\"\n", + " sigma = alpha * dt / dx**2\n", + " # Create the implicit operator of the system.\n", + " A = lhs_operator(len(T0) - 2, sigma)\n", + " # Integrate in time.\n", + " T = T0.copy()\n", + " for n in range(nt):\n", + " # Generate the right-hand side of the system.\n", + " b = rhs_vector(T, sigma, q * dx)\n", + " # Solve the system with scipy.linalg.solve.\n", + " T[1:-1] = linalg.solve(A, b)\n", + " # Apply the Neumann boundary condition.\n", + " T[-1] = T[-2] + q * dx\n", + " return T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And we are good to go! First, let's setup our initial conditions, and the matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "L = 1.0 # length of the rod\n", + "nx = 21 # number of points on the rod\n", + "dx = L / (nx - 1) # grid spacing\n", + "alpha = 1.22e-3 # thermal diffusivity of the rod\n", + "q = 0.0 # temperature gradient at the extremity\n", + "\n", + "# Define the locations on the rod.\n", + "x = numpy.linspace(0.0, L, num=nx)\n", + "\n", + "# Set the initial temperature distribution.\n", + "T0 = numpy.zeros(nx)\n", + "T0[0] = 100.0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the matrix..." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 6. -1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [-1. 6. -1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. -1. 6. -1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. -1. 6. -1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. -1. 6. -1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. -1. 6. -1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. 0. -1. 6. -1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. -1. 6. -1. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. -1. 6. -1. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. -1. 6. -1. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. -1. 6. -1. 0. 0. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. -1. 6. -1. 0. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. -1. 6. -1. 0. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. -1. 6. -1. 0. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. -1. 6. -1. 0. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. -1. 6. -1. 0.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. -1. 6. -1.\n", + " 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. -1. 6.\n", + " -1. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. -1.\n", + " 6. -1.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " -1. 5.]]\n" + ] + } + ], + "source": [ + "A = lhs_operator(nx - 1, 0.5)\n", + "print(A)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looks okay! Now, step in time" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the time-step size based on CFL limit.\n", + "sigma = 0.5\n", + "dt = sigma * dx**2 / alpha # time-step size\n", + "nt = 10 # number of time steps to compute\n", + "\n", + "# Compute the temperature distribution.\n", + "T = crank_nicolson(T0, nt, dt, dx, alpha, q)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And plot," + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the temperature along the rod.\n", + "pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel('Distance [m]')\n", + "pyplot.ylabel('Temperature [C]')\n", + "pyplot.grid()\n", + "pyplot.plot(x, T, color='C0', linestyle='-', linewidth=2)\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 100.0);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Works nicely. But wait! This method has elements of explicit and implicit discretizations. Is it *conditionally stable* like forward Euler, or *unconditionally stable* like backward Euler? Try out different values of `sigma`. You'll see Crank-Nicolson is an *unconditionally stable scheme* for the diffusion equation!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Accuracy & convergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using some techniques you might have learned in your PDE class, such as separation of variables, you can get a closed expression for the rod problem. It looks like this:\n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "T(x,t) = & \\nonumber \\\\\n", + "100 - \\sum_{n=1}^{\\infty} & \\frac{400}{(2n-1)\\pi}\\sin\\left(\\frac{(2n-1)\\pi}{2L}x\\right) \\exp\\left[-\\alpha\\left(\\frac{(2n-1)\\pi}{2L}\\right)^2t\\right]\n", + "\\end{eqnarray}\n", + "$$\n", + "\n", + "Unfortunately, the analytical solution is a bit messy, but at least it gives a good approximation if we evaluate it for large $n$. Let's define a function that will calculate this for us:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def analytical_temperature(x, t, alpha, L, N):\n", + " \"\"\"\n", + " Computes and returns a truncated approximation\n", + " of the exact temperature distribution along the rod.\n", + " \n", + " Parameters\n", + " ----------\n", + " x : numpy.ndarray\n", + " Locations at which to calculate the temperature\n", + " as a 1D array of floats.\n", + " t : float\n", + " Time.\n", + " alpha : float\n", + " Thermal diffusivity of the rod.\n", + " L : float\n", + " Length of the rod.\n", + " N : integer\n", + " Number of terms to use in the expansion.\n", + " \n", + " Returns\n", + " -------\n", + " T : numpy.ndarray\n", + " The truncated analytical temperature distribution\n", + " as a 1D array of floats.\n", + " \"\"\"\n", + " T = 100.0 * numpy.ones_like(x)\n", + " for n in range(1, N + 1):\n", + " k = (2 * n - 1) * numpy.pi / (2.0 * L)\n", + " T -= (400.0 / (2.0 * L * k) *\n", + " numpy.sin(k * x) * numpy.exp(- alpha * k**2 * t))\n", + " return T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And let's see how that expression looks for the time where we left the numerical solution" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Compute the analytical temperature distribution.\n", + "T_exact = analytical_temperature(x, nt * dt, alpha, L, 100)\n", + "\n", + "# Plot the numerical and analytical temperatures.\n", + "pyplot.figure(figsize=(6.0, 4.0))\n", + "pyplot.xlabel('Distance [m]')\n", + "pyplot.ylabel('Temperature [C]')\n", + "pyplot.grid()\n", + "pyplot.plot(x, T, label='numerical',\n", + " color='C0', linestyle='-', linewidth=2)\n", + "pyplot.plot(x, T_exact, label='analytical',\n", + " color='C1', linestyle='--', linewidth=2)\n", + "pyplot.legend()\n", + "pyplot.xlim(0.0, L)\n", + "pyplot.ylim(0.0, 100.0);" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6.927917118260093e-13" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "T1 = analytical_temperature(x, 0.2, alpha, L, 100)\n", + "T2 = analytical_temperature(x, 0.2, alpha, L, 200)\n", + "numpy.sqrt(numpy.sum((T1 - T2)**2) / numpy.sum(T2**2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That looks like it should. We'll now use this result to study the convergence of the Crank-Nicolson scheme." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Time convergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We said this method was second-order accurate in time, remember? That's in theory, but we should test that the numerical solution indeed behaves like the theory says.\n", + "\n", + "Leaving $\\Delta x$ constant, we'll run the code for different values of $\\Delta t$ and compare the result at the same physical time, say $t=n_t\\cdot\\Delta t=10$, with the analytical expression above.\n", + "\n", + "The initial condition of the rod problem has a very sharp gradient: it suddenly jumps from $0{\\rm C}$ to $100{\\rm C}$ at the boundary. To resolve that gradient to the point that it doesn't affect time convergence, we would need a very fine mesh, and computations would be very slow. To avoid this issue, we will start from $t=1$ rather than starting from $t=0$.\n", + "\n", + "First, let's define a function that will compute the $L_2$-norm of the error:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def l2_error(T, T_exact):\n", + " \"\"\"\n", + " Computes and returns the relative L2-norm\n", + " of the difference between the numerical solution\n", + " and the exact solution.\n", + " \n", + " Parameters\n", + " ----------\n", + " T : numpy.ndarray\n", + " The numerical solution as an array of floats.\n", + " T_exact : numpy.ndarray\n", + " The exact solution as an array of floats.\n", + " \n", + " Returns\n", + " -------\n", + " error : float\n", + " The relative L2-norm of the difference.\n", + " \"\"\"\n", + " error = numpy.sqrt(numpy.sum((T - T_exact)**2) /\n", + " numpy.sum(T_exact**2))\n", + " return error" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For fun, let's compare the Crank-Nicolson scheme with the implicit (a.k.a., backward) Euler scheme. We'll borrow some functions from [notebook 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_02_Heat_Equation_1D_Implicit.ipynb) to do this." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def lhs_operator_btcs(N, sigma):\n", + " \"\"\"\n", + " Computes and returns the implicit operator\n", + " of the system for the 1D diffusion equation.\n", + " We use backward Euler method, Dirichlet condition\n", + " on the left side of the domain and zero-gradient\n", + " Neumann condition on the right side.\n", + " \n", + " Parameters\n", + " ----------\n", + " N : integer\n", + " Number of interior points.\n", + " sigma : float\n", + " Value of alpha * dt / dx**2.\n", + " \n", + " Returns\n", + " -------\n", + " A : numpy.ndarray\n", + " The implicit operator as a 2D array of floats\n", + " of size N by N.\n", + " \"\"\"\n", + " # Setup the diagonal of the operator.\n", + " D = numpy.diag((2.0 + 1.0 / sigma) * numpy.ones(N))\n", + " # Setup the Neumann condition for the last element.\n", + " D[-1, -1] = 1.0 + 1.0 / sigma\n", + " # Setup the upper diagonal of the operator.\n", + " U = numpy.diag(-1.0 * numpy.ones(N - 1), k=1)\n", + " # Setup the lower diagonal of the operator.\n", + " L = numpy.diag(-1.0 * numpy.ones(N - 1), k=-1)\n", + " # Assemble the operator.\n", + " A = D + U + L\n", + " return A" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def rhs_vector_btcs(T, sigma, qdx):\n", + " \"\"\"\n", + " Computes and returns the right-hand side of the system\n", + " for the 1D diffusion equation, using a Dirichlet condition\n", + " on the left side and a Neumann condition on the right side.\n", + " \n", + " Parameters\n", + " ----------\n", + " T : numpy.ndarray\n", + " The temperature distribution as a 1D array of floats.\n", + " sigma : float\n", + " Value of alpha * dt / dx**2.\n", + " qdx : float\n", + " Value of the temperature flux at the right side.\n", + " \n", + " Returns\n", + " -------\n", + " b : numpy.ndarray\n", + " The right-hand side of the system as a 1D array of floats.\n", + " \"\"\"\n", + " b = T[1:-1] / sigma\n", + " # Set Dirichlet condition.\n", + " b[0] += T[0]\n", + " # Set Neumann condition.\n", + " b[-1] += qdx\n", + " return b" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def btcs_implicit(T0, nt, dt, dx, alpha, q):\n", + " \"\"\"\n", + " Computes and returns the temperature along the rod\n", + " after a given number of time steps.\n", + " \n", + " The function uses Euler implicit in time,\n", + " central differencing in space, a Dirichlet condition\n", + " on the left side, and a Neumann condition on the\n", + " right side.\n", + " \n", + " Parameters\n", + " ----------\n", + " T0 : numpy.ndarray\n", + " The initial temperature distribution\n", + " as a 1D array of floats.\n", + " nt : integer\n", + " Number of time steps to compute.\n", + " dt : float\n", + " Time-step size.\n", + " dx : float\n", + " Distance between two consecutive locations.\n", + " alpha : float\n", + " Thermal diffusivity of the rod.\n", + " q : float\n", + " Value of the temperature gradient on the right side.\n", + " \n", + " Returns\n", + " -------\n", + " T : numpy.ndarray\n", + " The temperature distribution as a 1D array of floats.\n", + " \"\"\"\n", + " sigma = alpha * dt / dx**2\n", + " # Create the implicit operator of the system.\n", + " A = lhs_operator_btcs(len(T0) - 2, sigma)\n", + " # Integrate in time.\n", + " T = T0.copy()\n", + " for n in range(nt):\n", + " # Generate the right-hand side of the system.\n", + " b = rhs_vector_btcs(T, sigma, q * dx)\n", + " # Solve the system with scipy.linalg.solve.\n", + " T[1:-1] = linalg.solve(A, b)\n", + " # Apply the Neumann boundary condition.\n", + " T[-1] = T[-2] + q * dx\n", + " return T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's do the runs!" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Update parameters.\n", + "nx = 1001 # number of points on the rod\n", + "dx = L / (nx - 1) # grid spacing\n", + "\n", + "# Define the locations on the rod.\n", + "x = numpy.linspace(0.0, L, num=nx)\n", + "\n", + "# Create a list with the time-step sizes to use.\n", + "dt_values = [1.0, 0.5, 0.25, 0.125]\n", + "\n", + "# Create empty lists to hold the errors for both schemes.\n", + "errors = []\n", + "errors_btcs = []\n", + "\n", + "# Compute the initial temperature distribution at t=1.0.\n", + "t0 = 1.0\n", + "T0 = analytical_temperature(x, t0, alpha, L, 100)\n", + "\n", + "# Compute the final analytical temperature at t=10.0.\n", + "t = 10.0\n", + "T_exact = analytical_temperature(x, t, alpha, L, 100)\n", + "\n", + "# Compute the numerical solutions and errors.\n", + "for dt in dt_values:\n", + " nt = int((t - t0) / dt) # number of time steps\n", + " # Compute the solution using Crank-Nicolson scheme.\n", + " T = crank_nicolson(T0, nt, dt, dx, alpha, q)\n", + " # Compute and record the L2-norm of the error.\n", + " errors.append(l2_error(T, T_exact))\n", + " # Compute the solution using implicit BTCS scheme.\n", + " T = btcs_implicit(T0, nt, dt, dx, alpha, q)\n", + " # Compute and record the L2-norm of the error.\n", + " errors_btcs.append(l2_error(T, T_exact))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And plot," + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAboAAAGHCAYAAADGE5f2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XlcVPX+P/DXWwQFVNxRQzC3Uq+Ae+ZNUdPSRFuu+itar0lmabb4zaRySbya3Wy5mWHXvN5oublUpuW1Eluupqi4Z+7khqmJIqAi798fM0wsA8wMM5yZw+v5eMxD+JzPfM57jsjbzzmfRVQVREREZlXN6ACIiIg8iYmOiIhMjYmOiIhMjYmOiIhMjYmOiIhMjYmOiIhMjYmOiIhMjYmOiIhMjYmOiIhMrbrRARDQsGFDbdGihSHnvnjxIoKDgw05d1XA6+tZvL6e4+3XdvPmzadVtZEjdZnovECLFi2QmppqyLlTUlIQExNjyLmrAl5fz+L19Rxvv7YicsTRurx1SUREpsZER0REpsZER0REpsZER0REpsZER0REpsZER0REpsZEZyARiRWRpMzMTKNDISIyLSY6A6nqClWNDwkJMToUIiLTYqIjIiJTY6IjIiJT4xJgRORTmjRpgoyMjBLloaGhOHnypAERkbdjj46IfIq9JFdWORETHRERmRoTHRERmRoTHRH5jBUrVhgdAvkgJjoi8gnLly/HnXfeaXQY5IOY6IjI6/3nP//B8OHDkZeXh6CgILt1QkNDKzkq8hVMdETk1Q4ePIi4uDhcvXoVzz33HLKysqCqUFWsXbvW9jWnFlBpOI+OiLxay5Yt8frrryMjIwNTp06FiBgdEvkYJjoi8krnz59HnTp1AABjx441OBryZbx1SURe55133kHbtm2xZ88eo0MhE2CiIyKv8o9//ANjxoxBRkYG1q1bZ3Q4ZAJMdETkNebOnYtx48YBAN544w2MGTPG4IjIDJjoiMgrzJ49G0899RQA4O2337YlPKKKYqIjIsMlJiZi0qRJEBG8++677MmRW3HUpZuISH0AcwBkA8gH0ALAM6q6z8i4iHxBo0aN4Ofnh3/+85944IEHjA6HTMb0iU5EmgJ4D8AtqurJCTjhAHJVdZz1vI8DeBdAHw+ek8gU4uPj0a9fP7Ru3droUMiETH3rUkTuALAeQKty6jUWkWQR2Wt9LRGRMGfOpappqvpYoaJDAJo6HzWR+akqpk2bhp07d9rKmOTIU0yd6ABMAjAAwI+lVRCRAABrAAQA6ACgPYCLANaKSK0KnDsWwPwKvJ/IlFQVTz75JKZOnYpBgwYhJyfH6JDI5Mx+67KXquaVs2TQAwAiAdyhqnkAICLPAjgG4FFYnrtBRNYDaF5KGzeo6tGCb0TkNgAhAF6r8CcgMpH8/HyMGzcO8+bNQ0BAAObNm4fAwECjwyKTM3WiK0hc5bgLQLqqHiz0vpMistt6bI61rKcj57QmuWEA7lPVfOejJjKn/Px8jBkzBgsWLECNGjWwfPlyDBo0yOiwqAow+61LR0TC8jytuEMAOjrTkIgMh+VW6SPWnuTrboiPyOddvXoVo0aNwoIFC1CzZk2sWLGCSY4qjal7dA5qCGCznfLzAIJEJFBVy32IICKRAD4EcBrA/7PeLg0B8EQp9eMBxAOWfbRSUlJcCr6isrKyDDt3VcDra5GWloZFixahZs2amDlzJvz9/d1yXXh9PcdM15aJrnROTUVQ1e1w4nqqahKAJADo2rWrxsTEOBWcu6SkpMCoc1cFvL4WMTExqF27Ntq0aYPevXu7rV1eX88x07VlorP0wGrbKa8NINuR3hwRlXT58mWkp6fbpg2MGjXK4IioquIzOmA7LKuYFHctgB2VGwqROVy6dAnDhw9Hz549i8yVIzICe3TAMgDviEgLVT0MACISCqAdgOc8eWIRiQUQy4my5OuaNGmCjIyMEuUigkuXLhkQEdEf2KMDFsHSc5stItVFpBqAWbCMunzbkydW1RWqGh8SEuLJ0xB5nL0kB1gmh3fp0qWSoyEqytSJTkTmiEgagKHW79Osr4CCOqp6GZYpAVcB7AawB0AdAP1UNcuAsImIyI1MfetSVSc6WC8DwD0eDoeIiAxg6h6dtxORWBFJyszMNDoUIiLTYqIzEJ/RERF5HhMdEbnkwoULuP3227Ft2zaEhobarVNaOVFlMvUzOiLyjPPnz+PWW2/F+vXrkZ6ejhMnTqCcXUKIDMMeHRE5JTMzE7fccgvWr1+P8PBwLFmyhEmOvBoTnYE4GIV8zblz5zBw4EBs2LABERERWLduHVq2bGl0WERlYqIzEAejkC/5/fffMWDAAGzcuBHXXnst1q1bhxYtWhgdFlG5mOiIyCHfffcdNm/ejJYtWyIlJQURERFGh0TkEA5GISKHDBs2DB9++CF69eqFsLAwo8MhchgTHRGV6vTp0zh+/DgiIyMBACNHjjQ4IiLn8dYlEdn122+/oV+/fujbty+2b99udDhELmOiMxBHXZK3OnXqFPr27YsdO3agcePGaNSokdEhEbmMic5AHHVJ3igjIwN9+/bFrl270L59e6xduxZNmzY1Oiwil/EZHRHZnDhxAv369cPPP/+MDh064Ntvv0Xjxo2NDouoQtijIyIAwOXLl3HzzTfj559/RseOHbF27VomOTIFJjoiAgAEBATg2WefRadOnfDtt9/yuRyZBhMdURWnqrav77//fmzcuBENGzY0MCIi92KiI6rC0tPT0b17d2zZssVWVr06H92TuTDRGYjTC8hIR44cQUxMDFJTU/Hcc88ZHQ6RxzDRGYjTC8gohw8fRkxMDA4dOoRu3brh448/NjokIo9hoiOqYg4ePIg+ffrg8OHD6NGjB9asWYO6desaHRaRxzDREVUhBw4cQExMDNLT09GzZ0/897//Be8okNnxqTORiTVp0gQZGRklyv39/bF69WrUrl3bgKiIKhd7dEQmZi/JAcCVK1eY5KjKYKIjIiJTY6IjIiJTY6IjMqk9e/YYHQKRV2CiMxAnjJOn7N69G3379jU6DCKvwERnIE4YJ0/YtWsX+vbti4yMDAQEBNitExoaWslRERmHiY7IRC5evIgBAwbg1KlTGDBgAM6dOwdVLfE6efKk0aESVRomOiITCQ4OxiuvvIJBgwbhs88+Q2BgoNEhERmOiY7IBPLy8mxf33PPPVi5ciWTHJEVEx2Rj9u+fTvatWuHTZs22cpExMCIiLwLEx2RD9u2bRv69euH/fv3Y+7cuUaHQ+SVmOiIfFRaWhr69euHM2fO4LbbbsN7771ndEhEXomJjsgHbd26Ff3798fZs2cxZMgQLF26FDVq1DA6LCKvxERH5GO2bNliS3KxsbFYsmQJkxxRGZjoiHzMgQMHkJmZiWHDhjHJETmA+9EZSERiAcS2bt3a6FDIhwwfPhyNGjXCjTfeWOrKJ0T0B/boDMQlwMhRmzZtwk8//WT7PiYmhkmOyEHs0RF5uY0bN2LgwIFQVWzYsAHt2rUzOiQin8IeHZEX++mnnzBgwABkZmZi4MCB4G1uIucx0RF5qQ0bNmDgwIE4f/48hg8fjg8++AD+/v5Gh0Xkc5joiLzQ+vXrbUluxIgRSE5OZpIjchETHZGXyczMxG233YYLFy5g5MiRTHJEFcTBKEReJiQkBPPnz8eKFSvw3nvvoXp1/jMlqgj+CyLyErm5uahZsyYAYMSIERgxYoTBERGZA29dEnmB77//Hq1atcKGDRuMDoXIdNijIzJAkyZNkJGRUaK8X79+yM7ONiAiIvNij47IAPaSHADk5ORUciRE5sdER0REpsZER0REpsZER0REpsZEZyARiRWRpMzMTKNDISIyLSY6A3GbnqorNDTUqXIich2nFxAZ4OTJk0aHQFRleKRHJyL/9kS7REREznK5RycirQH0AdAEgF+xw/0rEhQREZG7uJToRGQsgDcBSClV1OWIiIiI3MjVW5f/B+AxAI1UtVrxF4Dt7guRiIjIda7euvxNVeeXcfw+F9slIiJyK1d7dMtFpGMZxx9xsV0iIiK3cqlHp6ozRWS2iLQCsB9A8eXW7wIwrqLBERERVVRFBqNMLKMKB6MQEZFXcPXW5WRYbk825GAUIiLyZq4ORjmlqgvKOM7BKERE5BVc7dGt4WAUIiLyBa726C4B+FREtoKDUYiIyIu5muiet/55bSnHORiFiIi8gqu3LrfZG4TCwShERORtXE10kSKyVETCSjnO25ZEROQVXE10lwH8G0CGvYOq+oPLEREREbmRq8/otqnqp6UdFJFrVPWYi237JBGZCyAYwAUAUQDeVtWlxkZFRESu9ui+FZHeZRxf4WK7biUiTUXkKxGpjMExV1Q1XlWfBpAIIKkSzklEROVwtUeXB+B9EUkD8DOArGLHm1QoKjcQkTsAzAVwpZx6ja31ulqLdgCYoKpHnTmfqv5foW/bAdjqzPuJiMgzKjq9IAzAEDvHnepBicir1i9nqeopF2MqbhKAAQASALQu5bwBANYA+AVAB1jiXghgrYh0UtXiCbxMItIJwAsAmgG40/XQiYjIXbxlesF4AOmwPN9yl16quq+cOg8AiATwrKrmqepVAM8CaAng0YJKIrJeRI6W8rKNPFXVrap6JyzJ7gcRCXbj5yEiIhe42qN7sZzjzk4vSFPV10o7KCKiqk71ElU1z4FqdwFIV9WDhd53UkR2W4/NsZb1LKsREfEDEFjQA1TVNSJSG5bboeuciZuIiNzLpR6dqpY52MSF6QWpItKujOObnWzPUZEADtkpPwSgrLU8i2uOQoNPRKQZgNqltE1ERJXI1R4dRCQQlsWbBwBoCOA0gP8CSFLVHCeb2wZgqYh8DfuDW+q7Gmc5GsJ+Ej0PIEhEAh38LGcB+InIewB+B9AewIOqmu6+UImIyBXi5B1By5tEGgFIgWV0YS4sv9zrAagJYDeAGFU97UR7+eVUUVX1czpQS9uLADygqmLn2GUAq1U1tlh5MoB7AAS5kLQdjSseQDwAhIaGdvnoo488cZpyZWVloVatWoacuyrg9fUsXl/P8fZr27dv382q2rX8mq736GbDMnjk/6nqjoJC69Y9s6zHRznR3h4Ag0s5JgBWuhhneU7DcouxuNoAsj2V5ABAVZNgvd3ZtWtXjYmJ8dSpypSSkgKjzl0V8Pp6Fq+v55jp2rqa6PoCuE5VLxcuVNUdInIXLLcfnfGGqh4p7aCITHMhRkdsB3C9nfJrYZlPR0REPs7ltS6LJ7kCqpoLy351DlPVdwp/b33+V/j4f5yO0DHLAESISItC5w6F5ZYsl+8iIjIBVxNdpojYmygOERkKy2AOp4hIBxH5VESyAGSJSJaILBeR9i7G6IhFsPTcZotIdRGpBsut10MA3vbgeQEAIhIrIkmZmZmePhURUZXl6q3LGQCWi8g3AFJhGYxSH0A3WG5rOrUqiHVFke8AXATwPSyjGOsDuAHATyJyk6qmOdnmHFhGhIZbvy94f/eC3qiqXhaRAbAsAbYblpVRdgLo5+yqKK6wTtNY0bVr19GePhcRUVXlUqJT1c9F5F4ALwMYWOjQrwDiyptnZ8ffALwCILHwRG/rROwEWAa33OJkjBMdrJcBywhLIiIyIZfn0anqxwA+FpHrYJ1Hp6p7XWyujareauccVwFMF5GDdt5DRERULlef0dmo6l5V/bFwkhOR/7o5jgrH6Y34jI6IyPMqsjLKzQBiAIQCKD6Zu7OTze0UkdkAXlRV24hNEakJ4CWYdKg/n9EREXmeS4lORGYAmAzLUl2/Ayi+somz0+mfA/ADgHgR2YU/BrcUbJ3Ty5U4iYiIXO3RPQDgFlVdY++giDi16aiq7hSRLgCmAeiPP9bOXAFgmqrudzFOIiKq4lxNdBmlJTmrGGcaE5FI65ejCt+6JCIiqihXB3l8bZ37VpoZTraXBuA9AA1cjMcncTAKEZHnudqjuwzLtjpbAewDkF3s+F1wbvPVQwC6qWp5uxiYCgejEBF5nquJ7nnrny1KOe7s3j8HYOld2k10IvKSqr7gZJtEREQu37rcpqrVSnvBsiuAMyYBeFtEOotIkJ3jt7kYJxERVXGu9uheLOe4M7ctAct6mQrgrwAgUmKPVCIiIpe4utZlmWtZquoPTjaZAWB+KccE1p24iYiInOXyyiiFiUiSqlYkGW1R1VI3VxWR1hVo22uJSCyA2NatTfnxiDwmOTkZCQkJSE9PR3h4OBITExEXF2d0WOSl3LWGZNcKvv+/IjJeROrZO6iq91awfa+kqitUNT4kJMToUIh8RnJyMuLj43HkyBGoKo4cOYL4+HgkJycbHRp5KW9ZLHkugJYoZdQlEVGBhIQEZGcXndGUnZ2NhIQEgyIib+eWW5ewPEeriO2qOsEtkRCRqaWnpztVTuSuHt3DFXz/bhFpWtpBEfmygu0TkUk0aGB/AaXw8PBKjoR8hVt6dKq6uYJNLINlpZUlAH6GZVeEwlpVsH0iMoH8/HwEBgaWKA8KCkJiYqIBEZEvqHCiE5FrAbwL4FoAnwKYrKq51mMbVbW7A838x/rnDdY/C6+sInB+pRUiMqHPPvsMv/76K+rWrYvatWvj6NGjHHVJ5XJHj24eLD2yDbBMFP9GRG5V1QsA/B1s4wBKv/0pABZUOEovxOkFRI5TVUyfPh0AMH36dIwbNw4pKSmIiYkxNjDyeu5IdKGq+pb16wdF5DlYkt0AON4T+0BV15V2UETeKu2YL+OizkSO+/zzz5GWloamTZti9Gj+kyHHuSPR1Sj8jar+TUSuAPgGQG1HGlDVKeUcf8318IjIDG688UY8++yzaNmyJWrWrGl0OORD3JHofhGRAYU3YlXVV0QkH8ArjjYiIvUBPA7Lpq1+qtpHRB4DkKqqP7khTiLyYY0aNcKsWbOMDoN8kDsS3f+zV6iqr4rIx440ICJtAHwPIATAUQAB1kPnAXwiIveraoobYiUiH6OqyMvLg7+/o4/8iYqq8Dw6Vb2kqpdKOXbMwWb+DsvIy1BVbQPgrPX9/wYwGOXvlkBEJvXll1+ibdu2+Oijj4wOhXyU25cAE5FbRWSjk29rr6rjVfW89XvbIBZV3QkHn/URkbmoKqZNm4bDhw/j2DFH/99MVJQn1rqsAaCLm+No7GIsROTDVq9ejY0bN6JRo0YYM2aM0eGQj/KWRZ1/FpE3RCS4cKGI+InIDADbDIrLo0QkVkSSMjMzjQ6FyOsU9OYAYOLEiQgODi7nHUT2OZzoRKSjiLhrEejingVwP4CTIrIewLUi8jWAXwE8CuD/PHReQ3GbHqLSrVmzBhs2bEDDhg0xduxYo8MhH+ZMj24bgCwR2SIiC637x/UWkToVDUJVd8Cyp91nAFoAqAWgA4CvAXRT1Z8reg4i8h2Fe3PPPPMMe3NUIc700B4DEAUgGsAIAA/COmhERI4ASLO+arkSiKruB2DKDVaJyDmnTp3C8ePH0aBBAzz22GNGh0M+zuFEp6pvF3wtIgLgOliSXsGrJ4DbC6q7MUYiqmJCQ0Pxyy+/YM+ePahVy6X/OxPZuPTMTVUVlu10fgZgm9wiIqEAOgOIdEt0RFRl+fv7IzKSv0qo4tw66lJVM1T1S1Wd7c52iajqmDdvHk6dOmV0GGQi3jK9gIgIKSkpeOyxx9C5c2fk5eUZHQ6ZBBMdEXmNgpGW8fHxqF7dU7OZqKrxukQnIuEi0sn6NX/SiaqI7777DikpKQgJCcH48eONDodMxGsSnYjcKyIHABwC8IW1+H0Rec06ypOITKxg9/AJEyagbt26BkdDZuIViU5E7gWwAMBGAFMAXLAeehpAMwAJBoXmUVwCjMjixx9/xDfffIM6dergiSeeMDocMpkKJTrryigvisgs6/d9RMSVnQaeAXCzqt6tqjMAZAO2bX4eAnBHReL0VlwCjMii4NncE088gXr16hkcDZmNS8/ArMlsGYD+1qKTACYBGARgkYj0U9VDTjRZQ1V/tHdAVS/yWR2Rub3wwgsIDAzEhAkTjA6FTMjVHt0sAEGwJLZwAKcAQFUnAXjOetwZNayTzUuwlnM/OiITu+mmm/DZZ5+hfv36RodCJuRqorsVwC2qulpVjwLILzigqh8BaOVke8sAfC8iD4nIdQD8ROQaEbkNwCoUWn2FiMzj8uXLRodAVYCrtwSvqGpWGcedHTL1PIB2AP4JyzqZAiDdeuwLWAaoEJHJ3HHHHfD398frr7+OiIgIo8Mhk3I10V0UkbtUdWnxAyIyGMBZZxpT1VwAt4nIzbA892sI4DSANar6rYsxEpEX27hxI1atWoXg4GBuw0Me5WqimwFgiYj8AOB/ABqJyPOwbOMTC+AuVxpV1a9h2YOuCBEJV9V0O28hIh9VMG/u8ccfR8OGDQ2OhszMpWd0qrocwD2wbJL6LIBrAEwH0A1AnKqudFeAVp+6uT0iMlBqaipWrlyJoKAgPP3000aHQybn8rB9Vf0YwMfWwSMNAZxW1b2utGXdpfz/AMQACAXgV6xKM1fjJCLvU9Cbe+yxx9CoUSODoyGzc3Ue3VZV7QQA1uTmUoIr5F0A/QCsB3AAhUZxwjIwZUgF2yciL7FlyxasWLECQUFBeOaZZ4wOh6oAV3t0HURkI4DFAD5U1TMVjKMXgA6qmmHvoIh8UsH2ichLpKamwt/fH48++igaN25sdDhUBbia6HYBGAngQQD/E5FdAP4F4AtVvepCe/tLS3IAoKrDXYqSiLxOfHw8Bg0ahMDAQKNDoSrC1Qnjg1X1kKpOUdXrALwBy3qU+0RkrohEO9neP0VkTGm7FIjIehfjJCIv1Lx5c460pErjUo9OVU8U+z5FRM4BuALgCQDjUXJAiY2I2Jsb1w7AdBE5COuizoV0cCVOIvIeu3btwq5du/CXv/wF1ap5xcYpVEW49NMmIousfzYWkSdFJA3AZgDDYRlY0rucJrrBMsik8OtnWG6J5tg5RkQ+bsqUKRg5ciRmzpxpdChUxbj6jG6giHwOy5qX1WCZ5D0bwHLrKifl2a+qfR09mYhsdS1M7yYisQBiW7dubXQoRB61Y8cOLF26FDVq1MBf//pXo8OhKsbV+wdNYFm4+XkA4ap6q6p+6GCSA4DBjlQSkQAR8QPQ08U4vRr3o6OqYsaMGQCA0aNHo1kzToulyuVqotuhqh1U9WVVPe7sm4s/4xOR10qpOgiW3cbvcSFGIvICu3fvxieffIKAgAA8++yzRodDVZCria5HWQdFZJ6T7dl9pqeqn8GyfuZTTrZHRF7ipZdegqri4YcfRlhYmNHhUBXk8DM6EbkGwCVVPQ1gRCkzAQo4dGvSQdkAarqxPSKqJHv27MHHH38Mf39/TJo0yehwqIpyZjDKVgCHYOnNLSqnrpbXmIhMAfBioe/Lmmj+mQPxEZGXiYiIwKuvvoqzZ8+iefPmRodDVZQzie4hAOetX+9B6b02AeDI7gUpheo/AmC+nTpXYEmuyxyOkoi8RlBQECZMmGB0GFTFOZzoim2987KqHileR0SaAWgJ4GUH2lsHYJ31feGqOs3RWIjI+126dAk1atQwOgwilwejjC6lvCWA9wHc4ExjqsqJNUQm8ssvvyAsLAyzZs0yOhQilyeM2933XlV/EJFWANJcD4mIfF1iYiJOnz6N/fv3Gx0KkVOjLsNh2VEcAIJF5CaUXJ5LAIQBqO2W6IjI5+zfvx/Jycnw8/PD5MmTjQ6HyOnBKFPwx4jKFDt1BJZNU1+qWFhE5GuSk5ORkJCAI0csj+979+6Nli1bGhwVkXOJbhEsyU0ALADwsJ06VwAcLm+1FBG5H0A0gP9T1TwnYiAiL5ScnIz4+HhkZ/+x8cjGjRuRnJyMuLg4AyMjcm7U5REARwBAROZaR026ajKAFwqSnIjcqaqcQkDkoxISEookOQDIzc1FQkICEx0ZzqVRl6pa5hJfIlJeAs1V1U8Kff98Oe1VJKkSkYelp6c7VU5UmVwddVmejQA6l3G8mog8BOBHALkAAkSkOUrfe66Bm+MjIjcKDw+3PZsrXk5kNJcTnYh0BjAKlrlzxWeFlrfB2hQAycXed9jVWIjIWImJiSWe0QUFBSExMdHAqIgsXEp0IjIIwBIA2wH8CUCq9VATANcV+t4uVV0uIq1h2Wm8HoBpKLTuZfHTAZjqSpxEVDn8/f0xffp0vPnmm0hPT0d4eDgSExP5fI68gqs9uhcB9FfVDSKytfBu4SIyHA6sjGIdmfmZ9T29VPVfpdUVkV4uxklEHnb69Gk89NBDyM3NxcGDBxEREWF0SERFuLoEWKCqbrB+XeS5mnWQSSdnGlPV0pYUc+i4NxGRiSJS7u4NRGbx2muvITs7G4MGDWKSI6/kaqIrvKVOnog0LfhGROoCuN7ZBkUkUEQmiMhKEfnJ+ucTIhLoYowQkaYi8lVlJR4R+ROAmMo4F5E3OHfuHN58800AlikGRN7I1UR3TESmi0gNWHYg+K81KT0By6Ty3c40JiKNYHmu9yqAvrAsI9YXwFwAm0SkobMBisgdANYDaFVOvcYikiwie62vJSLi9DbIIuIPIBHAc86+l8hX/eMf/8D58+fRv39/9OzZ0+hwiOxyNdG9CqCR9ZUI4AIsSWkugFoAxjnZ3mwA6QCiVDVIVa9R1SAAUbBMUp/tQoyTAAyAZQqDXSISAGANgAAAHQC0B3ARwFoRqeXk+aYCeB1/7NlHZGpZWVmYO3cuAOD558ucCktkKJcGo6hqCgqtdWkdLNIalukCP7uwrFdfANep6uVi59khIncB+NmFMHupap5IaVPzAAAPAIgEcEehVVqeBXAMwKMA5ljL1gMobXvkG6zHglT1WxFp4UKsRD5n/vz5OHv2LHr16oU+ffoYHQ5RqdwyYVxVFcC+gu9FZJ6qjnWiicvFk1yhtnNF5JILMTmSbO8CkK6qBwu976SI7LYem2MtK/OejIiMA1BPRObDunOD9etviq0AQ2QaQ4YMwfbt2xEXF4dy/kNJZCiHEp11EWZnDHayfqaIDFHVL+yceyg8dzswEsAvdsoPAejvaCOq+mzB19Ye3T2qOqaiwRF5s+uvvx6LFy82Ogyicjnao1vkZLvOjnKcAWC5iHwDy6CU3wGooF0KAAAgAElEQVTUh2VCeV8AdzrZnqMaAthsp/w8gCARCVTVHEcbE5EYWLYzgoj8A0CSqm4vpW48gHgACA0NRUpKinORu0lWVpZh564KzHh98/PzISJe0Ysz4/X1Fqa6tqpa7gvALgARDr5aANjlSLvFzjESloEn+YVeRwCMcLatYu0ugvXuqp1jlwGssFOeDEuyDqzIuR19denSRY2ydu1aw85dFZjx+i5YsEB79OihKSkpRodiyuvrLbz92gJIVQd/xzrao3tDLdv0OERE3nC0bgFV/RjAxyJyHSw9rdOqutfZdpx0GvZ3Q68NIFud6M0RVQV5eXn429/+hoMHD+LEiRNGh0PkEIcSnaq+Y69cRHrDMkE6SFUniUgfAFtKq+/gufYC8HSCK7Ad9ie3XwtgRyXFQOQzPvroIxw8eBBt2rTB8OHDjQ6HyCEuzaMTkdoisgaWKQZTARQMVhkEYLsPDbFfBiCicLwiEgqgHYClnj65iMSKSFJmZqanT0VUYfn5+bbdCJ577jn4+fkZHBGRY1ydMD4LQBAsiS0cwCkAUNVJsKwM4soEbyMsgqXnNltEqotINVg+2yEAb3v65Kq6QlXjQ0JCPH0qogpbtmwZfv75Z4SHh+Pee+81Ohwih7ma6G4FcIuqrlbVo7AMHAEAqOpHKGfZrcogInNEJA3AUOv3adZXQEEdtczdGwDL2p27AewBUAdAP1XNMiBsIq+kqpgxYwYAYNKkSfD39zc4IiLHuTph/Eo5iaCui+26japOdLBeBoB7PBwOkU/bv38/Dh8+jKZNm+Khhx4yOhwip7ia6C6KyF2qWuI5logMBnC2YmERkTdp06YNjhw5gr1796JmzZpGh0PkFFcT3QwAS0TkBwD/A9BIRJ6HZRHmWFiWz6JyiEgsgNjWrVsbHQpRuUJCQtC9e3ejwyBymkvP6FR1OSy3+1oAeBbANQCmw7KSSZyqrnRXgGbGwSjkC/7zn/8gJ4dTSsl3uToYBar6sapGwDIU/yYA7VS1haouFREOySIyge+//x4jR45E586dkZ+fX/4biLyQy4mugKruVdUfi61i8lRF2yUi4xXMmxsxYgSqVavwrwsiQzj1kysiNUSkt4jcLiLX2DneU0Q+h+VZHRH5sE2bNmH16tWoVasWxo8fb3Q4RC5zONFZVw9JA7AWllVD9onIEOux/iKyDsAPsDynm+72SE2IK6OQNyvozY0dOxYNGjQwOBoi1znTo5sNy2r/TwOYBOAogFesm46uARAM4EEA4ao6zc1xmhIHo5C32r59Oz777DPUrFkTTz3FJxHk25yZXtANQHdVPQ0AIrIclk1L4wDcrKrfeiA+IjLAzJkzAQDx8fEIDQ01OBqiinEm0eUWJDkAUNX9InIawJDC5UTk++644w7s27cPEyc6tMAQkVdz5tblJTtlx+0lORGZ6XpIRGS0kSNHYvPmzQgLCzM6FKIKcybRqZ2y0ibW3OpCLERERG7nzK3LaBG5WqxM7JSRg7gEGHmbCRMm4PLly3j++efRrFkzo8MhcgtnEt3vAD53oJ4AGOJaOFWLqq4AsKJr166jjY6F6OjRo3j77bdx5coVjB8/nomOTMOZRJeuqg7tzyEiW12Mh4gM8sorr+Dy5csYMWIErr/+eqPDIXIbZ57RDfRQXSIyWEZGBpKSkgAACQkJBkdD5F4OJzpV/c0TdYnIeHPnzkVOTg6GDh2KyMhIo8Mhciuu0kpUxZ09exZvvfUWAPbmyJyY6AzEtS7JG6xatQpZWVkYOHAgN1YlU3J1h3FyA466JG9w7733okOHDvDz8zM6FCKPYKIjInTq1MnoEIg8hrcuiaqo7Oxs/O9//zM6DCKPY6IjqqKSkpLQq1cvPPHEE0aHQuRRTHREVdClS5cwZ84cAED//v0NjobIs5joiKqgRYsW4fjx44iMjMSQIVyxj8yNiY6oirly5QpmzZoFwDJvrlo1/hogc+NPOFEV88EHH+Dw4cO47rrrcNdddxkdDpHHMdEZiBPGqbJdvXoVM2da9kWePHky585RlcBEZyBVXaGq8SEhIUaHQlVEbm4uhg4dio4dO+Luu+82OhyiSsFER1SFBAcHY86cOUhLS4O/v7/R4RBVCiY6oiqIA1CoKuFPO5HJJScnIyIiAiKCBg0aYPHixUaHRFSpuNYlkYklJycjPj4e2dnZACxb8owZMwZ+fn6Ii4szODqiysEeHZGJJSQk2JJcgZycHO47R1UKEx2RiaWnpztVTmRGTHREJhYeHu5UOZEZMdERmdiTTz5ZoiwoKAiJiYkGRENkDCY6IhM7ffo0AEtyExFEREQgKSmJA1GoSuGoSwOJSCyA2NatWxsdCpnU888/jzZt2iA6OhqRkZFGh0NkCPboDMQlwMjTatSogfvvv59Jjqo0JjoiE8rPz8e5c+eMDoPIKzDREZnQypUrERYWxkEnRGCiIzKluXPn4uLFiwgMDDQ6FCLDMdERmcy2bduwdu1a1KpVC6NGjTI6HCLDMdERmczrr78OAHjooYfAgU5ETHREpnLq1CkkJydDRDB+/HijwyHyCkx0RCby9ttv4/Lly4iNjQXnZxJZcMI4kQ/Lzc3Fb7/9htzcXOTl5aFv377o0aMHQkNDsWfPHqPD87iQkJAq8TmNYNS19ff3R+PGjVGnTh23tclER+SjMjMzkZGRgUaNGqFJkyaoXr062rVrh5ycHNSsWRMiYnSIHnfhwgXUrl3b6DBMyYhrq6rIycnBsWPHAMBtyY63Lol81OnTpxEWFoZ69erB39/fltgCAwOrRJIj8xERBAUF4ZprrsGpU6fc1i4THZGPunz5sm2eXE5ODi5evGhwRETuERgYiCtXrritPSY6Ih9W0HM7duwY9uzZg99++83giIgqzt13JJjoiHxcbm4uzp07BxFB3bp1jQ6HyOsw0RlIRGJFJCkzM9PoUMiHFTzLqF+/Pvz9/Q2OxrxefPFFtG7dGiKClJQUo8NxCzN+JnuY6AzEbXqoovLy8mybq4aGhhocjXtt374d9957LyIjIxEdHY0OHTogJiYGs2bNwt69eys9nunTp+Pdd9916b0XLlxAdHQ0mjRpAhHB8uXLS9SZOHEi2rdvj4CAAERHR2Px4sUAgK1bt6J+/frYuHFjheK3pyKfyZcw0RH5sDNnziA/Px+1a9dGUFCQ0eG4zb/+9S/07t0bQ4cORVpaGtLS0rBz506MGzcOM2fORI8ePYwO0Sm1a9dGWloaxowZAwAYNWoUfv311yJ15syZg1WrVqFZs2ZIS0vD/fffDwAIDg5GREQEgoODKz1us2CiI/JRqoqMjAwA5urNbdmyBaNHj8bf//53jBgxAtWqWX5NiQjuuusuvPbaawZHWDGDBw9GVlYW4uLicPXq1XLrt23bFlu3bkWHDh0qITpzYqIj8lGqirp16yIoKMhtizcnJyejRYsWqFatGlq0aIHk5GS3tOuMGTNmIDg42NajKW7kyJH4y1/+guPHj6NXr16oVasWYmJi8P777+Omm25CgwYNbINy1q5di9jYWHTu3BlRUVHo0aMHVq1aVaS9wYMH224pbtq0CbfccgtatGiBG264Abt27Soz1oLrFRQUhOjoaKxdu7bcz9etWzfMnj0b33//PV566aUy665evRrR0dEQEUydOrXIsd27dyM2NhYRERGIiopC9+7dMWvWLGRlZdnq7Ny5E0OGDEGLFi1w7bXXYuDAgdiyZUu5MR47dgwPPvggIiMj0alTJ9xwww2YPXt2kTq//vor7r77bkRERKBVq1a48cYb8c0339iOf/7557bYX3jhBTz77LPo0qULwsLCkJCQUG4MbqWqfBn86tKlixpl7dq1hp27KvDk9d29e7eqqubn57ulvffff1+DgoIUgO0VFBSk77//vlvad0ReXp7WqlVL+/Xr51D98+fPa58+fbRRo0aamJioqqonTpzQRo0aqarqI488opMnT7Zdox9//FEDAwN106ZNRdqZMmWKAtDx48fr1atX9cqVK9q7d2/t2bNnkXpr165VALa/14yMDO3SpYt+++23DsU7ZcoUnTJliqqqDh06VP38/HTdunW244cOHdKIiIgS7wNge5+q6v79+7Vu3br61FNP2T7bsmXLVER069atqqq6b98+rVOnjj799NO2OlOmTNHg4GDdvn17qZ9JVbV///764IMP2t73xRdfqCVdWJw+fVqbN2+uI0eO1CtXrqiq6sKFC9XPz09Xr15dIvaIiAhNTU1VVdXVq1crgBL1iiv4+S4NgFR18Hes4b/k+WKiM7PKSHT2FE5WxV/vvPOOrd4777xTZt2CX1Kqqp07dy61zujRo21tFvxCc0VGRoYC0Lvvvtuh+gWJrm7dunrp0iVb+b59+1RV9ciRI5qdnV3kPT169NAxY8YUKStIdAVJQlV1zpw5CkBzc3NtZYWTwunTp7Vbt27l/sIufp6ChHXmzBkNDw/XsLAwPXPmjKo6nujuvfderV27tl68eLFIvZtuukm3bdumqqpxcXFap06dIp//8uXL2rhxY42NjbX7mQoEBwfriy++WKTtyZMn275OSEhQEdH09PQidTp16qQdO3YsEfuwYcOKlNWqVUufe+65Ep+zMHcmOt66JPJBU6dORVZWFvLz8z1+rvT0dI+fozhnJwy3atUKAQEBtu8Ldm4IDg7G888/jy5duthGb+7cuRMHDx60207btm1tX9evXx8A7C5F9fvvv+Pmm2/Gn/70JwwcONCpWAu3/9FHH+HkyZNOb5C7Zs0adOjQocQApO+++w6RkZEAgK+//hodOnQossu8v78/OnXqhK+//trS0ylF7969MWvWLDz66KP43//+h/z8fCQmJtqOf/3112jSpAmaN29e5H3du3fHjh07bM+OCxS+rgBQr169EnU8iYmOyMccP34ciYmJOHPmTKnLJJX1v9v4+Hhbvfj4eFt5RESE3bbCw8MBAJs3by61zaSkJFv9Ll26uPzZGjRogODgYJw8edKp99WqVatEWX5+PmJjY/HVV1/hs88+w/bt25GWloauXbvi0qVLdtspnDgKBsHYGzAyduxYhIaG4t///je2bt1a5NiLL76I6Oho2+vzzz8vNe6ePXsiMTERn376KebNm+fQZwUs65wWJOKy6tSrV69Eef369ZGTk4Ps7OxS37tkyRI888wzWLlyJXr16oVrr722yDSEstouOF5Y8YRcrVo1hwbiuAsTHZGPmTdvHvLy8hAUFIQaNWq4rd3ExMQSv5CCgoKK/E/e0/z8/HDLLbdgy5YtpSbxs2fP4quvvsL58+fLbGv//v1Yv349Ro0ahbCwMLfGOXXqVHz66ado2bIlRo0ahby8PNux6dOn26ZEpKWlYejQoWW2NXHiRAwaNAhPP/00duzY4dD5GzZsiN9//73cOmfPni1RfvbsWQQGBpY5HSUoKAiTJk3CkSNH8M033yAiIgKjR4/G119/XW7bBce9CRMdkQ/JycnB/PnzAbhvC5MCcXFxSEpKQkREBEQEERERSEpKQlxcnFvPU54pU6YgJycH77//vt3jiYmJGDt2bLnzBgt6bcVvgzrbW7TnuuuuQ82aNfHPf/4TaWlpePnll11uS0SwePFiNGjQAKNHj3boPQMGDMCuXbuQk5NTpHzEiBG2FU5uvvlm7Nq1q0jPLS8vD2lpabj55pvLvD18991322Lr168fPv30UwCWSfwFbWdkZJS4rb1p0yZ07NjR66a7MNER+ZD3338fZ86cQdeuXd3amysQFxeHw4cPIz8/H4cPH670JAcAkZGRWLx4MZ5++mksWbLE9hzyypUr+Mc//oEFCxZg4cKFqF697O00r7/+erRs2RLvvfeerffzySefuHVVlT//+c947LHHMH36dPz8888ut9OwYUN8+OGHJW75lWbq1KmoVq0apk6danvW9v7772Pr1q22yfRTpkyxDe0vqDNz5kxcuHCh3F76Rx99VOSW6w8//AA/Pz/07t0bAPDkk08iLCwMEydOtPVmFy9ejG3btuGVV15x7sNXBkdHrfDFUZfkPHde3/z8fG3fvr0C0OTk5HJHpfm6tLQ0HTlypLZv316joqK0Y8eOet999+nOnTtVVTU7O1s7duyowcHBGhwcrFFRUbps2bIibezcuVP79u2roaGh2qdPH50wYYJ26dLFVv/SpUt6zz33aGhoqALQqKgo3b59u/7tb3/T5s2bKwBt166dfvLJJ/rqq69qq1atFIC2atVKX331Vf3222+1bdu2CkBDQ0P1vvvus/tZzp8/r1FRURoaGqqhoaEaFRWl58+fL1FvxowZRUZdfvXVVxoVFWVrv/BoyV27dultt92m4eHhGhUVpcOGDdMDBw4UaW/Hjh06ePBgDQ8P14iICL355puLjIp94YUXinymadOmqarq7NmztXPnzhoZGamRkZHavXt3/fTTT4u0feTIER05cqQ2b95cW7ZsqT179tQ1a9bYjn/33XdFYh87dqz+/vvvGhUVpf7+/lqvXj3t379/qX//7hx1KVrGyBuqHF27dtXU1FRDzp2SkoKYmBhDzl0VuPP6rlmzBgMHDkSzZs1w6NAhHDhwAO3atXNL276KO4x7jtHXds+ePWX+fIvIZlXt6khbZff9ichr/PnPf8aCBQtQvXr1IkPpiahsTHREPiIwMBAPP/yw0WEQ+RwORiHyAYWHrxORc5joiLzc2bNnER4ejqeeeqpSVkIhMhsmOiIvt2DBApw4cQK7du2yrdZBRI7jvxoiL3blyhW8+eabACxzl4jIeUx0biIii0TkZKHXfKNjIt+3dOlSHDt2DNdff73LiwcTVXWmHnUpIk0BvAfgFlV1bjl0F6hqE0+fg6oOVcXcuXMBABMmTOBtSyIXmTbRicgdAOYCsL8y7B/1GlvrFUw83AFggqoedeGciQBqABAAs1W15P4eRA7asGEDNm7ciPr16+O+++4zOhwin2Xm/yJOAjAAwI+lVRCRAABrAAQA6ACgPYCLANaKSMl9P8r2OYA3VfUZAP8D8I2ImPY/EuR5q1atAgA88sgj5S5gTESlM/Mv4l6qmlfOBo4PAIgEcIeq5gGAiDwL4BiARwHMsZatB9C8lDZuUNWjqrqsoEBVl4rIe9a2t1T4k1CV9NJLLyE2Nta2HxwRuca0PbqCxFWOuwCkq6ptu2FVPQlgt/VYQVlPVQ0r5XUUAESk+KJslwEEgqgCunfvjiZN+OjXl/3222+YOXOm0WFg8ODBaNKkidO7t7tDWloaFi1aVOnnLWDaROegSACH7JQfAtDRybb+XfCFiHQCkA9gu+uhUVV18eJFhzfgNJNTp04hOjoa9evXh4jYduhu2bIlIiIi8NBDD9n2kjt8+DACAgLQq1cvW71atWohICCgyO7etWrVsu3PBlgWKp4+fTq6deuGzp07o3379ujSpQseffRRrFmzpshmr/n5+Xj33XfRo0cPdOrUCVFRUejQoQNGjhyJhQsXOvSZTp48iV69eqFNmza2si+++AKNGjXCr7/+6p4L56BVq1ZhzJgxJcrnzZuHFi1alLnjuD32Pse5c+cwdepUpKWlFanbrl07fPTRR5g4caJrwVeQmW9dOqIhgM12ys8DCBKRQFXNsXPcnh0i8hGAkwBaw3I79EJplUUkHkA8AISGhhb5x1iZsrKyDDt3VeDK9V2+fDneeOMNDB8+HGPHji21XkhICC5cKPVHzOcEBgbi+++/x5gxY/DBBx/g+++/tx3bunUrBg0ahIMHD+KLL75AVlYWmjZtiu+++w5+fn4ALD2W9PT0Iu8bPHgwsrOzceHCBaSnp2PYsGHo2bMnli1bhrp16wKw7EQ+btw4zJ8/Hx988AGGDBkCwLKf24cffogVK1bguuuuA2BJxn/961/xwgsvYPjw4eV+pnvuuQd9+vTBrbfeavu7ql69Opo3b44rV65U+t9fwWa0hc8bGBiIa665BtnZ2bh69aqt/OrVq2XGZ+9zHD16FNOmTUOTJk3QqlWrIvXfffdddOzYEZ06dUJsbGy5sebm5rrvd5Oj+/n46gvAIsvHtHvsMoAVdsqTASiAwMqIkfvRmZez1/fq1avapk0bBaCffPJJmXXNuh/dAw88oNZ/s0UMHTpURUQvXLigJ0+e1Pvvv7/Inm59+vQpspebqurEiRN127ZtevXqVe3atavedNNNmp+fX6Lts2fPap06dXT58uW2sgYNGuiECRNK1N2yZYtec8015X6O1NRUBVBijzgjTZkyxe61tcfefnnlOXTokALQ9957z+7xiRMnqqO/79y5H11Vv3V5GoC9DZdqA8hWx3tzRG7x5ZdfYt++fQgPD8ftt99eqecueH5T/OUtzwgLFrYWEYSGhuJf//pXue95+eWXERkZiS+++AKpqakYN26c3WdU9erVwwsvvICwsDBb2ZUrV5Cenl6ibnR0NDZs2FDuuZcsWYLmzZujZcuWtrL33nsP7du3h4jYnlmlpqYiOjoaAQEBePDBB/Hyyy+jR48eCA0NRUJCAgDLMnA33ngjwsLC8Pzzz9vaO378uO0WbUxMDF577TV0794dTZs2RY8ePbBp06YyY0xMTETr1q0hIiV6T19++SW6deuGtm3bomPHjhg4cCD+/e9/l/o5li9fjsGDBwMAXnzxRdvt43Pnztna7N+/PzZv3owDBw6Ue/3cytGM6KsvlN2j+wrAYTvlOwBsqKwY2aMzL2evb//+/RWAzpkzp9y67u7RwXIXw+6rMtnr0a1cuVL9/f318ccfL1JeXo+uwKOPPqoAND093eE4hg0bpgD0r3/9q6alpTn+Aax69Oihffv2LVFeWq8nIiJCmzRpol999ZWqqq5evVoB6OOPP24rW7VqlQIospO3quWzBwUFaUJCgqpa7gw8+OCDGhISor/99putnr0e3dq1axVAkZ/VTz75RP38/Gw93KtXr+pTTz2lISEhZX6O8np0BceTkpLsHi+MPTr3WQYgQkRaFBSISCiAdgCWevrkIhIrIkmZmZmePhX5gB07duCbb75BcHBwhfeds9czK3glJSXZ6iUlJdnKy9OlS5dS24yPj7fV27zZ3mNv5xX0CJo2bYphw4bh4Ycfxssvv+xSW4cPHwZgeR7uqHnz5qF3795YuHChbVDMk08+iW3btjn0/pMnT6Jhw4ZOxdm0aVPccsstAICBAweidu3a+PHHH21lgwYNQq1atbB27doS761evbqtt1etWjXMnDkTWVlZeO2115yKQVXx9NNP46abbrLdVahWrRqmTZuGWrWcnV5cVKNGjQAAJ06cqFA7zqrqiW4RLL232SJSXUSqAZgFy6jLtz19clVdoarxISEhnj4V+YDXX38dAPDQQw/ZBkpUZWlpaUhLS8OJEydw6NAh7N27F9HR0cjIyKiU8zdr1gzr1q3DTz/9hAkTJsDPzw+vvfYaoqOjMX78+HLff+rUKdSsWdOpc7Zu3brI9/Xq1StRVr9+fdvo08JatWpV5HxNmzZFs2bNsH79eqdi2Lt3L9LT09G5c+ci5bVq1cLRo04vGFVEQXyV9XdYwLSJTkTmiEgagKHW79Osr4CCOqp6GZbVU67CMnduD4A6APqpapYBYVMVVrt2bQQHBzv0S7Q8Zd3GKdz7io+PL3zLvkybN28utc3CvcQuXbpUOP7iwsLC8MYbb+CXX35xqVcXEREBwLVfsN27d8fcuXOxb98+/PDDD4iMjMSbb76JNWvWlPk+Pz8/h65rYcVXwBERu2WFR0cWqFOnTomyevXq4fjx407FcPr0adt73a3gelSvXrkD/k2b6FR1oqpGq2p9VRXr19HW5Fa4Xoaq3qOqbVX1OlW9S1Urd4ILEYC5c+fi5MmTReZc0R8Khqvv3r3b6fcWDJIoaxDJunXrsGfPHtv3ycnJJRJKr1698Pbblps9W7duLfOcoaGhyMmpvPFs58+fL1F29uxZNGvWzKl2Cm63Fh5E4i4Fc/WcuYXsDqZNdL6Az+iouIo+A6mI0n75VPYvpdIUTEx2JZ4hQ4agZ8+eeOutt+we3759O2JiYoo8O0pISMC+fftK1C3YRaK8529hYWGVeovuwIEDyM3NtX1/4sQJHD9+HD179nSqneuuuw7h4eHYsqXo6oVnz57FDTfcUGYC9Pf3B/BHz23z5s345ZdfbMcLbrk2b17aioqewURnID6jI8AyjDs5ORmXL18uv7IHnTx50u5tSXvPgypbVlYWJk+ejOrVqxe59eooEcHSpUuRkZGB0aNHo/B/Ljdv3ow777wTjz32GPr161fkfU888USRZHXixAk899xzaNasGe68884yzzlo0CDs3bvX6Vhd5e/vj8TERACWVV0SEhJQu3ZtTJgwwal2RAR///vf8f3332PFihUALFM7Jk+ejFatWpX5/Dg0NBSBgYG2Z3lPPPFEkV707t274efnh1tvvdXZj1cxjg7P5IvTC8h55V3f/Px87dSpkwLQxYsXO9W22SaMZ2RkaFRUlNarV08BaFRUlEZFRWmHDh00PDxcb7vtNl23bl2R95w/f163b9+uUVFRGhwcrP7+/hoVFWUbjl/c+fPn9cUXX9To6GiNiorSyMhIvemmmzQ5OblE3eXLl+sDDzygHTt21OjoaG3btq1ee+21+uCDD+qhQ4fK/Tz79+9XEdHU1FRb2cKFC7Vdu3YKQJs3b66PPPKI7t+/X6OiotTf31/r1aunt99+u54+fbrcspiYGFu7ffr00T59+ujChQu1R48e2qRJE+3WrZtu3LjRVmfQoEEaGhpqu7YrV67UGTNmaKtWrRSAtmrVSqdNm2ar//HHH2vXrl21devW+qc//UnHjRunFy9eLPVzFJg/f76Gh4drhw4d9Pbbb9ecnBzbsVGjRumAAQPKvXaq7p1eIOrkw1Jyv65du2pqaqoh505JSUFMTIwh564Kyru+395B8cAAAAh7SURBVH33Hfr06YPGjRvjyJEjTo3S27NnD9q1K76WeNVy4cIF1K5tb80H7zB69GicOXMGy5YtK79yBRT8jLlzOT93X9sjR46gQ4cO+Pbbb9G9e/dy65f38y0im1W1a6kVCuGtSyKDJCcn227hXLp0CUuXenzqJlWyN954A+fPn7fdUqyqzpw5g6FDh+Ktt95yKMm5GxOdgTgYpepKTk7G6NGjbaPyMjMzER8fj+TkZIMjI3cKDAzEV199hfbt2xsdiqHOnTuHhQsX4oEHHjDk/Ex0BlIORqmyEhISSgw9z87Otq1tSOZRvXp13HHHHR5pu2Cty9TUVNuamWfOnPHIuSqiVatWHplf6aiqvk0PkSHsLRZcVjmRPc2aNSux9xuVxB4dkQHCw8OdKici1zHRERkgMTGxxNJOQUFBVX7QApEnMNERGSAuLg5JSUmIiIiAiCAiIgJJSUmIi4tzqh1ODyIzcvfPNZ/RGUhEYgHEFl+dnKqGuLg4pxNbYQEBAcjJySnRMyTydTk5ObblxNyBPToDcdQlVUTDhg1x9OhRnD17FleuXGHvjnyeqiI7OxvHjh1D48aN3dYue3REPiokJAQ1atTAb7/9hjNnziAvL8/okCpdbm6u03u+kWOMurb+/v4IDQ21u+2Qq5joiHxYzZo1K30leG+SkpKCTp06GR2GKZnp2vLWJRERmRoTHRERmRoTHRERmRoTnYG4qDMRkecx0RmI0wuIiDyPiY6IiEyNO4x7ARH5DcCRYsUhAEq7p1naMXvlxcuKf98QwGmHg62Ysj6TO9/rSF1nr6+j19yo61uRa+vs+8ur66mfXXtlvnB9jf7ZLa3cW3527Z3bERGq2sihmqrKlxe+ACQ5e8xeefEyO9+nesNncud7Hanr7PV19JobdX0rcm3dfX099bPrq9fX6J9dJ66lT/5ucOTFW5fea4ULx+yVFy8rq11Pq8i5nXmvI3Wdvb6OXnOjrm9Fz+vO6+upn11Hzu0pvvyzW1q5t/zsevzcvHVZxYlIqqp2NToOs+L19SxeX88x07Vlj46SjA7A5Hh9PYvX13NMc23ZoyMiIlNjj46IiEyNiY6IiEyNiY4cJiL1ReSfIvKmiLwuIp+JSBuj4zITEfEXkWdE5KKI/MnoeHyZiISLyKciMl9EvuD1dC9f+lllojMBEWkqIl+JiKcfuIYDyFXVcar6BIA1AN718DkNV4nXFwDiAfwIIKgSzuWV3Hi93wbwoaqOATADQHLFo/N9bry+PvOzykTn40TkDgDrAbQqp15jEUkWkb3W1xIRCXPmXKqapqqPFSo6BKCp81H7jsq8vgCgqm+p6npX4/V17rreItIAwCAAKwFAVTcAaCYi0R4M3+u58+fZl35Wmeh83yQAA2D5n5VdIhIAS+8rAEAHAO0BXASwVkRqVeDcsQDmV+D9vsDI6/v/27ubUCvKMIDj/yfEPkAhCoMy1EUfBt1QCLToAwkKDEv6UCJ1GUK7FkEQtKyMKAhqUXBLoVoYRItqUZQEtYqbUS4iS0u8lFJpFKX1tJi5cDpc9X7MmeN55/+DWcw77xme8/De+8w7M2emi5rK9zLgj8z8veejPwErBhH0COnkeF4w7AA0bzdm5smIOF2fbcAYsDEzTwJExKPAIWA7sKNu+xS4/BT7WJOZP06tRMR6qufTPTfvb3B2G0p+O6ypfJ92Bx3W2HgeJc7oRtzUQDyDe4CDmbm/53OTwNf1tqm2tZm59BRLf5G7C9iSmf82923OPsPIb5c1mO/vgQv6ZiBLqE63d1aT43mUWOi6YYzp/8C/A66dzY4i4j6qUx8P1UeGzzcQ36hrLL+akTPmOzOPAu8B6wEiYg1wODMn2gpyhBU3ni103XAxcHya9mNUR73nz2QnETEGvA5sBg5HxCTVnVdd10h+ASLi5oh4oV59LCI2NRFgYWaa7+3AAxHxEvA48GBL8Y26GeV3lMaq1+i6bVbXMTJzL46Z2Zj1daLM3APsAR5uPpzi/S/fmXmA6hS7mtGf35EZq87ouuEIsGia9kVUd6b92XI8pTG/7TLfg1Vcfi103bAXWD5N+wrgy3ZDKZL5bZf5Hqzi8muh64a3gGURsXyqISIuAVYCu4cUU0nMb7vM92AVl18LXTeMUx2JPRURCyLiHOBJqruoXhxmYIUYx/y2aRzzPUjjFJZfC92Ii4gdETEBbKjXJ+pl4VSfzPyb6icB/1D9FmYfsBhY1/fkCPUxv+0y34PV1fz64lVJUtGc0UmSimahkyQVzUInSSqahU6SVDQLnSSpaBY6SVLRLHSSpKJZ6CRJRbPQSZKKZqGTBEBEvBwRGRHPnmL74oh4IiJWth2bNB8+AkwS9VujJ6neOfYzcFlmnuzrsw74ALiufgmvNBKc0UkC2Ej14N6ngSXAHdP0WQX8RfWgX2lkOKOTRES8D1wBXAUcAj7KzPt7tu8Dru772O7MvLe9KKW5cUYndVxEXArcBuzKzBPAG8CGiLiwp9tWYD/wDrC2Xh5pO1ZpLix0krZQ/S/YVa+/BpwLbOrp8wWwFPgwMz+rlwPthinNjacupY6LiK+A45m5pqdtH/BLZt5Qr68CPgduycw9w4lUmhtndFKHRcT1wDXAzr5NO4G1EXFlvb4aSGCixfCkRljopG7bBpwA3uxr30VV2LbW66uAbzPzWIuxSY2w0EkdFRELgc3Au5l5pHdbZh4EPga2RERQzfr8WYFG0oJhByBpaO4ELgJ+iIi7p9m+H7i1Xn4FVkfE7cBvwDeZebSlOKV58WYUqaMi4m1gwwy6vgo8A7wCjAHnATdl5icDDE9qjIVOklQ0r9FJkopmoZMkFc1CJ0kqmoVOklQ0C50kqWgWOklS0Sx0kqSiWegkSUWz0EmSimahkyQV7T/JiMGlYfnfCwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the error versus the time-step size.\n", + "pyplot.figure(figsize=(6.0, 6.0))\n", + "pyplot.grid()\n", + "pyplot.xlabel(r'$\\Delta t$')\n", + "pyplot.ylabel('Relative $L_2$-norm\\nof the error')\n", + "pyplot.loglog(dt_values, errors, label='Crank-Nicolson',\n", + " color='black', linestyle='--', linewidth=2, marker='o')\n", + "pyplot.loglog(dt_values, errors_btcs, label='BTCS (implicit)',\n", + " color='black', linestyle='--', linewidth=2, marker='s')\n", + "pyplot.legend()\n", + "pyplot.axis('equal');" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.0005562525604218684,\n", + " 0.0001374575644793469,\n", + " 3.285170428405964e-05,\n", + " 6.771647468538648e-06]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "errors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "See how the error drops four times when the time step is halved? This method is second order in time!\n", + "\n", + "Clearly, Crank-Nicolson (circles) converges faster than backward Euler (squares)! Not only that, but also the error curve is shifted down: Crank-Nicolson is more accurate.\n", + "\n", + "If you look closely, you'll realize that the error in Crank-Nicolson decays about twice as fast than backward Euler: it's a second versus first order method!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Spatial convergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To study spatial convergence, we will run the code for meshes with 21, 41, 81 and 161 points, and compare them at the same non-dimensional time, say $t=20$. \n", + "\n", + "Let's start by defining a function that will do everything for us" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "dt = 0.1 # time-step size\n", + "t = 20.0 # final time\n", + "nt = int(t / dt) # number of time steps to compute\n", + "\n", + "# Create a list with the grid-spacing sizes to use.\n", + "nx_values = [11, 21, 41, 81, 161]\n", + "\n", + "# Create an empty list to store the errors.\n", + "errors = []\n", + "\n", + "# Compute the numerical solutions and errors.\n", + "for nx in nx_values:\n", + " dx = L / (nx - 1) # grid spacing\n", + " x = numpy.linspace(0.0, L, num=nx) # grid points\n", + " # Set the initial conditions for the grid.\n", + " T0 = numpy.zeros(nx)\n", + " T0[0] = 100.0\n", + " # Compute the solution using Crank-Nicolson scheme.\n", + " T = crank_nicolson(T0, nt, dt, dx, alpha, q)\n", + " # Compute the analytical solution.\n", + " T_exact = analytical_temperature(x, t, alpha, L, 100)\n", + " # Compute and record the L2-norm of the error.\n", + " errors.append(l2_error(T, T_exact))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And plot!" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAboAAAGHCAYAAADGE5f2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XmYFOW5/vHvw84gogiCKDAioBElmuCCS4K4JCpIhHPQI1GiKG7RI6KCMwiyKWBUJIsGIVHjKEaJW1yCiSJHf8YVoggoIwouQYPmoDCyDPP8/ugezjjO0l3TM29P9f25rr6YrqquvpNyeHir3sXcHRERkbhqEjqAiIhIfVKhExGRWFOhExGRWFOhExGRWFOhExGRWFOhExGRWFOhExGRWFOhExGRWFOhExGRWGsWOoBAhw4dPD8/P3QMyZDNmzfTpk2b0DEkEF3/hvH6669vcPeOqRyrQpcF8vPzee2110LHkAxZvHgxAwYMCB1DAtH1bxhmtjbVY3XrMiAzG2xmczdu3Bg6iohIbKnQBeTuj7v76Hbt2oWOIiISWyp0IiISayp0IiISayp0IiISayp0IiISayp0AanXpYhI/VOhC0i9LkVE6p8KnYiIxJoKnYiIxJoKnYhIBhQVFZGfn8/AgQPJz8+nqKgodCRJ0lyXIiJ1VFRUxOjRoykpKQFg7dq1jB49GoARI0aEjCaoRSciUmeFhYU7i1y5kpISCgsLAyWSilToAtLwApF4WLduXVrbpWGp0AWk4QUi8dCxY9XLonXr1q2Bk0hVVOhEROrA3atcaDUvL4/p06cHSCSVqdCJiNTBQw89xPvvv8+uu+5K165dMTO6d+/O3Llz1RElS6jQiYhEtH37dgoKCgCYOXMm69at49lnn+WDDz5QkcsiKnQiIhHNmzeP4uJievfuzahRo0LHkWpoHJ2ISESHHnooRx11FFdeeSXNmzcPHUeqoUInIhLRkUceyQsvvBA6htRCty5FRNK0Y8eOnT+bGWYWMI3URoUuIA0YF2mcxowZw9ChQ1mzZk3oKJICFbqANGBcpPF57733uP3223nkkUe+Ne2XZCcVOhGRNEyYMIHS0lJGjhzJQQcdFDqOpECFTkQkRa+99hoLFiygZcuWTJkyJXQcSZEKnYhICtydcePGAXD55ZfTtWvXwIkkVSp0IiIpWLRoEc8++yy77bYb1157beg4kgYVOhGRFLz99ts0a9aMgoICdt9999BxJA0aMC4ikoIrr7ySIUOG0KVLl9BRJE0qdCIiKdpvv/1CR5AIdOtSRKQGf/jDH3jwwQdx99BRJCIVuoA0M4pIdtu4cSNXXHEFw4cP57nnngsdRyJSoQtIM6OIZLdZs2bxxRdfcOyxx3LccceFjiMRqdCJiFThk08+4dZbbwUSBU8TNzdeKnQiIlW4/vrr+frrrxk6dChHHnlk6DhSByp0IiKVrFq1ivnz59O0aVNuuOGG0HGkjlToREQqufnmmykrK+P8889n//33Dx1H6kjj6EREKpkzZw69e/fmpz/9aegokgEqdCIilbRu3Zqrr746dAzJEN26FBFJevvtt/nf//3f0DEkw1ToRESA0tJShg8fzn777cfSpUtDx5EMUqETEQHuueceVqxYQbt27TjwwANDx5EMUqETkZxXUlLCxIkTAZg+fTotW7YMnEgySYUuIM11KZIdfvnLX/Lxxx9z6KGHcsYZZ4SOIxmmQheQ5roUCe/zzz/nxhtvBGDmzJk0aaK/FuNGV1REctqNN97Ixo0bOfHEEznxxBNDx5F6oEInIjnt5JNP5vvf/z4zZswIHUXqiQaMi0hOO/7443n11Ve1OkGMqUUnIjmptLR0588qcvGmQiciOen000/n7LPPZv369aGjSD1ToRORnLN48WL+/Oc/8+ijj9K0adPQcaSeqdCJSE5xd6655hoArrnmGjp27Bg4kdQ3FToRySkLFy7k1VdfpXPnzowZMyZ0HGkAKnQikjO2b99OQUEBANdffz1t2rQJnEgaggqdiOSMefPmsXr1anr37s15550XOo40EBU6EckZa9eupUmTJtxwww00b948dBxpICp0IpIzZsyYwapVqxg6dGjoKNKANDOKiOSUXr16hY4gDUwtOhGJvZtvvpknnngCdw8dRQJQiy4gMxsMDO7Zs2foKCKxVVxczPjx49mxYwfvvvsu+n3LPWrRBaT16ETq34QJEygtLWXkyJEqcjlKhU5EYuvVV1/lgQceoGXLlkyZMiV0HAlEhU5EYsndGTduHACXX345Xbt2DZxIQlGhE5FYWrRoEc899xy77bYb48ePDx1HAlKhE5FYuvnmmwEoKCigffv2gdNISOp1KSKxtHDhQn7zm9/w85//PHQUCUyFTkRiqW3btjuf0Ulu061LEYmVl19+mc2bN4eOIVlEhU5EYmPjxo2ceuqp9OzZk48++ih0HMkSKnQiEhuzZs3i888/p3fv3uy9996h40iWUKETkVj45JNPuPXWW4FEwTOzwIkkW6jQiUgsXH/99Xz99dcMGzaMI444InQcySIqdCLS6K1atYr58+fTtGlTpk+fHjqOZBkVOhFp9AoKCigrK+OCCy5g//33Dx1HsozG0YlIozdy5Eg+/PBDJk6cGDqKZCG16ESk0RsyZAivvvoqe+21V+gokoVU6ESk0dq2bVvoCNIIqNCJSKNUWlpKv379uPDCC9m4cWPoOJLF9IxORBqlu+++m7feeotNmzbRqlWr0HEki6lFJyKNTklJCZMmTQJg2rRptGzZMnAiyWYqdCLSaBQVFZGfn0+bNm34+OOP6d69O2eeeWboWJLlVOhEpFEoKipi9OjRrF27due29evXc//99wdMJY2BCl1AZjbYzObqQbpI7QoLCykpKfnGtq1bt1JYWBgokTQWKnQBufvj7j66Xbt2oaOIZL1169altV2knAqdiDQK3bp1S2u7SDkVOhFpFKZPn05eXt43tuXl5WkSZ6mVCp2INAoffvghV1xxBd27d8fM6N69O3PnzmXEiBGho0mW04BxEcl6K1asoLCwkCZNmrB27Vq6dOkSOpI0ImrRiUjWmzhxImVlZZx//vkqcpI2FToRyWpvvPEGCxcupFWrVkyYMCF0HGmEVOhEJKuVF7dLL72UvffeO3AaaYxU6EQka7344os89dRT7LLLLowfPz50HGmkVOhEJGvNmDEDgDFjxtChQ4fAaaSxUq9LEclad999N7Nnz2bs2LGho0gjpkInIlmrffv2TJkyJXQMaeTq5dalmf2hPs4rIrnhvffeY+vWraFjSExEbtGZWU/gh0BnoGml3cfXJZSI5K4dO3bwk5/8hI0bN/LUU0/Rp0+f0JGkkYtU6MzsEuCXgFVziEdOJCI57YEHHmD58uV069aNnj17ho4jMRD11uU1wKVAR3dvUvkFvJm5iCKSK7Zv386kSZMAmDRpEi1btgycSOIg6q3Lf7n7HTXsPzvieUUkh911110UFxfTu3dvzjnnnNBxJCaitugeNrODa9h/YcTzikiO2rJly84elpMnT6ZZM3UKl8yI9F+Su99gZjPNbD+gGCipdMgw4LK6hhOR3PHb3/6Wjz76iL59+zJ8+PDQcSRG6tIZ5eoaDlFnFBFJS7du3ejRowfTpk2jSRNN2iSZE/XeQAGJ25ML3f2LyjvNbGmdUolIzjn99NMZNGiQbllKxkX9L+ozd7+zhv3qjCIiaWvevHnoCBJDUe8PPKPOKCKSCVOnTmXMmDF89tlnoaNITEVt0W0FHkneolRnFBGJ5LPPPmPmzJls3ryZ4cOHs+eee4aOJDEUtdCVL/O7bzX71RlFRGp14403snnzZgYNGkT//v1Dx5GYinrr8h9VzYiimVFEJFUfffQRt99+O5C4fSlSX6IWur5mttDM9qlmv25bikiNpk6dytatWxk+fDiHHHJI6DgSY1EL3TbgD8CnVe109xciJxKR2CsuLmb+/Pk0adKEyZMnh44jMVeXW5ePuPv2qnaa2d51yCQiMffoo4+yY8cOzjnnHA444IDQcSTmonZGedbMfuDuS6rZ/zjwvYjnFpGYGzt2LP3792effap7+iGSOVELXSlwr5ktA1YBmyrt71ynVI2Qmd0KtAG+Ar4L3O7uC8OmEsleRx11VOgIkiPqOrxgH2BQFfvTGl5gZrckf5zh7hkbNWpmewG/B37k7tUtEpsp2919dPJ7jwMeAlToRCpYvnw5mzdv5ogjjggdRXJItgwvuBxYR6I1lBFmdjrwErBfLcftaWZFZvZO8vVQDb1Jq+Xu11R4+x1A832KVDJ27FiOPPJI7rrrrtBRJIdELXQTa9mf7vCCZe4+292/rmqnmUVpjY0HTgRerO4AM2sBPAO0APoABwKbgefMbJd0v9DMDjWzPwHnJF8ikrRkyRIWLVrErrvuyuDBg0PHkRwSqdC5++O17E93eMFrZvadGva/nub5AI5299W1HDMS6AuMc/dSd98BjAN6ABeXH2RmL5nZR9W8drb+3H2puw8FrgNeMLM2EXKLxI67U1hYCMCVV17JHnvsETiR5JLI62GYWWsSkzefCHQANgCLgLnVtcxq8A9goZn9lao7t7RPN5+7l6Zw2DBgnbuvqfC59Wa2IrnvpuS2GucmMrOmQGt335Q8/hkzawv0A55PN7tI3PzlL3/hhRdeYI899mDMmDGh40iOibrwakdgMYlnUVuAfwMHAycDF5jZAHffkMYpf538s7oBNfU1d2Zf4N0qtr8PHJ/GeboCNwBnAZhZF6Bt8jwiOc3dmTAh0X9t/Pjx7LrrroETSa6J2qKbSaLzyJnu/lb5xuTSPTOS+0elcb6VwCnV7DPgiYg5a9OBqm+LfgnkmVnrFFunXwBNzez3JIr+gcDP3H1ddR8ws9HAaIBOnTqxePHidLNLltq0aZOuZwVLlizh9ddfZ4899uDggw+O/f83uv7ZJ2qhOw7Y3923Vdzo7m+Z2TAStx/TMcfd11a308waeo6gtDq/uPuXwBlpfmYuMBegX79+PmDAgHQ+Llls8eLF6Hr+nwMOOIANGzZw8MEH86Mf/Sh0nHqn6599oha6bZWLXDl332JmW9M5mbv/tuL7yi0pd/9jtJi12kDiFmNlbYGSCM8aRaSSzp07M2fOnNAxJIdFHV6w0cyqGiiOmZ1G4tZfWsysj5k9YmabgE1mtsnMHjazAyNmTMWbQH4V2/cF3qpiu4ikqLS0lNLSVPqEidSvqIVuGvCwmT1tZtPMbKyZTTezRSRmA5mSzsnM7FDg78CRwP8AC5J/Hgm8bGb1tYbHn4DuZpZfIUsnEp1sNKuJSB3Mnz+fAw88kKeeeip0FMlxkW5duvtjZvZTYBZwUoVdHwIjahtnV4UbgV8A0ysOC0h22y8k0bmlPm7u3wX8HJhpZiOAMhKdad4Hbq+H7xPJCVu2bGHq1Kl8/PHHbNpUebSQSMOKPI7O3R8AHjCz/UmOo3P3dyKerpe7/7iK79gBTDGzNVV8pkZmdhOJMX7dku+XJXcdXv580d23mdmJwK3AChLDGJYDA8vHxNUnMxsMDO7Zs2d9f5VIg7r99tv5+OOPOeSQQxg2bFjoOJLjIhe6csni9o0CZ2aL3P2kaj5SldpuoaZ9i9Xdr07xuE9Jjn9raMmW7+P9+vW7IMT3i9SHr776ihtuuAGAadOm0aRJ1CckIplRl5lRTgAGAJ2AppV2p7sW3XIzmwlMdPedPTbNrBUwFXUMEWk0brvtNjZs2MBRRx3FKadUNzxWpOFEnRllGlBAYqquf5N4tlVRuhMiXwu8AIw2s7eT52xPYqJlB46OklNEGtYXX3zBL37xCwCmT59OtPnYRTIraotuJIk13p6paqeZpbVEjbsvN7PvA5NJTL1VPnfm48Bkdy+OmFNEGlBxcTG77LILhx12mAZNS9aIWug+ra7IJQ1I52Rm1jf546iKty5FpHE5/PDDKS4u5vPPPw8dRWSnqE+J/5oc+1adaWmebxmJlcBzau0OMxtsZnM3btwYOopIxrRq1Yq99947dAyRnSJPAUZiWZ2lwGqgpNL+YaS3+Or7wGHuXvlZX6yp16XExbp165g7dy5jx45l9913Dx1H5BuiFroJyT/zq9mf7rI675FoXVZZ6Mxsqrtfl+Y5RaSBTJ06lXnz5vHPf/6T+fPnh44j8g1Rb13+w92bVPciMYdkOsYDt5vZ98wsr4r9p0bMKSL1bPXq1fz+97+nadOmjB8/PnQckW+J2qKbWMv+dG5bArxGohV4HqAuySKNyKRJk9ixYwejRo2iV69eoeOIfEvUuS5rnMvS3V9I85SfAndUs89ILlAqItnlzTffZMGCBbRo0YKJE2v7969IGHWeAgzAzOa6e12K0RvuXu3iqmamySBFstB1112Hu3PRRRfRrVu30HFEqpSpSej61fHzi8zscjOrsruWu/+0jucXkQxbvnw5jz32GHl5eRQUFISOI1KtjLToMuBWYA7V9LqMK61eII1Znz59eOaZZ1izZg2dOnUKHUekWpkqdHXtPfKmu1+RkSSNiMbRSWNmZpxwwgmhY4jUKlO3Ls+v4+dXmNle1e00My1RLJIl3J133303dAyRlGWk0Ln763U8xZ9IzLRypZmdYmY/qPgC9stATBHJgCeffJIDDjiAyy5LdxSRSBh1vnVpZvsC84B9gUeAAnffktz3irsfnsJp/pj888jknxVnVjHSn2lFROpBWVkZEyZMwN3Zd999Q8cRSUkmntH9hkSL7O8kBor/zcx+7O5fAc1TPMd7VH/704A765xSROps4cKFLFu2jC5dunDxxReHjiOSkkwUuk7u/uvkzz8zs2tJFLsTSb0ldp+7P1/dTjP7dXX7RKRhlJaW7hwUft1119G6devAiURSk4lC17LiG3e/0cy2A38D2qZyAnefVMv+2dHjiUgm3HvvvaxatYoePXpw3nnnhY4jkrJMdEZ5N9l628ndfwHcRxqdSMysvZlNNLNnzez55LZLzeyIDGTMSlqPThqLbdu2MXlyYvKi66+/nhYtWgROJJK6TBS6M4EllTe6+y1A11ROYGa9gBXAtcnP5Cd3fQk8aGYDMpAz67j74+4+ul27dqGjiNSopKSE448/nr59+3LWWWeFjiOSljrfunT3rTXs+zjF09xMouflBHf/MrmgK+7+h+TPc4DFdc0qItHstttuzJs3j61bt9K0adPQcUTSkqkB4zuZ2Y/N7JU0P3agu1/u7l8m3+/sxOLuy0nxWZ+I1K+WLVvWfpBIlsl4oSPROeX7Gc6xZ8QsIlIHX375JQMHDuSxxx7DXcNZpXGqj0IXxSozm2NmbSpuNLOmZjYN+EegXCI5bfbs2Tz33HPcdNNNoaOIRJbyMzozOxhY6e6l9ZBjHPA/wLlmthzY18z+ChxIooV4dD18p4hUo6ioiPHjx/PRRx8BMGDAAMzqOne7SBjptOj+AWwyszfM7HfJ9eN+YGa71jWEu79FYk27R0n0uNwF6AP8FTjM3VfV9TtEJDVFRUWMHj16Z5EDuOWWWygqKgqYSiS6dHpdXgp8FzgEGA78jGSnETNbCyxLvnaJEsTdiwEtsCoSWGFhISUlJd/YVlJSQmFhISNGjAiUSiS6lAudu99e/rMl7mHsT6Lolb/6Az8pPzyDGUWkAa1bty6t7SLZLtI4Ok90v1qVfC0o325mnYDvAX0zki7mtMK4ZKOuXbtWWdS6desWII1I3WW016W7f+ruT7n7zEyeN640M4pkoxtuuOFbEzbn5eUxffr0QIlE6iZbhheISJYYMWIEd955J927d8fM6N69O3PnztXzOWm0MrF6gYjExNNPP80xxxzDiBEjVNgkNrKuRWdm3czs0OTPKsQiDeT9999n8ODB9OrVi6+++ip0HJGMyZpCZ2Y/NbP3gPeBPyc332tms00jVUXq3bRp0ygtLeXEE0+kbVtNLyvxkRWFzsx+CtwJvAJMAsr/OTkW6AIUBoomkhOKi4u5++67adq06c5VxEXiok6FLjkzykQzm5F8/0Mzi/JPwauAE9z9v9x9GlACO5f5ORc4vS45RaRmU6ZMYceOHYwcORINd5G4iVTozKytmT1DYo2464FzkrtOBt40s33TPGVLd3+xqh3uvhl1mhGpN6tWraKoqIhmzZoxYcKE0HFEMi5qi24GkEeisHUDPgNw9/EkVgmfkeb5WiYHm39LcrseGIjUkylTplBWVsaoUaPYd990/40qkv2itpR+DHzX3TcBmFlZ+Q53X2BmV6V5vj8B/2NmNwL/D2hqZnuTmFpsChVmXxGRzDrjjDMoLi6moKAgdBSRehG10G0vL3LV2C3N800AvgPMJzFPpgHlcxD9mUQHFRGpB0OGDGHIkCGhY4jUm6iFbrOZDXP3hZV3mNkpwBfpnMzdtwCnmtkJwPFAB2AD8Iy7Pxsxo4jUoKysjCZNsqLjtUi9ilropgEPmdkLJG41djSzCSSW8RkMDItyUnf/K4k16L7BzLq5e+ymTtekzhLSGWecQbt27Zg2bRqdO3cOHUek3kT655y7PwycRWKR1HHA3iSepR0GjHD3JzIVMOmRDJ8vK2hSZwnl9ddf56GHHuK+++4LHUWk3kXutu/uDwAPmNn+JG81uvs7Uc6VXKX8GmAA0AloWumQLlFzisi3TZqUeOx96aWXqjUnsRep0JnZUnc/FCBZ3CIVuArmAQOBl4D3gLIK+wwYVMfzi0jSyy+/zBNPPEGbNm245pprQscRqXdRW3R9zOwV4B7gfnf/vI45jgb6uPunVe00swfreH4RSSqf4uuyyy6jY8eOgdOI1L+oXa7eBs4AOgL/z8z+ZGZDzKzyLcdUFVdX5ADc/T8jnldEKnjhhRdYtGgRbdu25aqr0h3uKtI4RS10p7j7++4+yd33B+aQmI9ytZndamaHpHm++WZ2UXWrFJjZSxFzikgFS5YsAeCKK65gjz32CJxGpGFEunXp7v+s9H6xmf0vsB34b+Byvt2hZCczq2ps3HeAKWa2huSkzhX0iZJTRL6poKCAQYMG0bVr19BRRBpM1Emd70r+uaeZjTGzZcDrwH+S6Fjyg1pOcRiJTiYVX6tI3BL9uop9IpIhffv2Zffddw8dQ6TBRO2McpKZPUZizssmJAZ5zwQeTs5yUptidz8u1S8zs6XRYooIwCuvvMKmTZsYOHBg6CgiDS7qM7rOwH4k5qjs5u4/dvf7UyxyAKekcpCZtUh2cOkfMadIznN3rrjiCo4//njuueee0HFEGlzUQveWu/dx91nu/km6H678jM/MZldz6MkkVhs/K0JGEQH+8pe/8NJLL9GhQweGDh0aOo5Ig4ta6I6oaaeZ/SbN81X5TM/dHyUxf+aVaZ5PREi05srHzY0bN45ddtklcCKRhpfyM7rk+nBb3X0DMLyakQDlUro1maISoFUGzyeSM5544gleffVVOnXqxCWXXBI6jkgQ6XRGWQq8T6I1d1ctx3ptJzOzScDECu931HD4oynkE5EKKrbmxo8fT15eXuBEImGkU+jOBb5M/ryS6lttBqSyesHiCsdfCNxRxTHbSRTXP6WcUkQAeOSRR1i6dCldunThwgsvDB1HJJiUC12lpXdmufvayseYWRegBzArhfM9Dzyf/Fw3d5+capa40Hp0Up9++MMfUlBQQI8ePWjdunXoOCLBRO2MckE123sA9wJHpnMydz8vYo5GTevRSX1q374906dPZ9SoUaGjiAQVtdC1qWqju79AYnzdMZETiUid7Nixg61bt4aOIZI1Ui50ZtbNzH5gZj8A2pjZseXvK7x+CJwJtK23xCJSowULFtCrVy/++Mc/ho4ikhXS7Ywyif/rUbm4imOMxKKpU+sWS0SiKC0tZfLkyXz44Yds3rw5dByRrJBOobuLRHEz4E7g/CqO2Q58UNtsKWZ2DnAIcI27l6aRQURqUFRUxOrVq9lvv/04++yzQ8cRyQrp9LpcC6wFMLNbk70moyoArisvcmY21N01hECkDrZv386UKVMAmDRpEs2aRZ2zXSReInVGcfcap/gys9p+w7a4+4MV3k+o5Xx1KaoiOeHuu+9mzZo17L///vzXf/1X6DgiWaO+/sn3CvC9GvY3MbNzgReBLUALM+tK9WvPaSlkkRps27aNqVMTj8bVmhP5psi/DWb2PWAUibFzLSvtrm0E9CSgqNLnPoiaRSTXffDBB7Ro0YI+ffowfPjw0HFEskqkQmdmJwMPAW8CBwGvJXd1Bvav8L5K7v6wmfUksdL47sBkKsx7WfnrgOuj5BTJFb1792blypV89NFHNG3aNHQckawStUU3ETje3f9uZksrrhZuZv9JCjOjJHtmPpr8zNHufnd1x5rZ0RFziuSMZs2akZ+fHzqGSNaJOjNKa3f/e/LnbzxXS3YyOTSdk7l7dVOKpbRfJFeVlJRQUFDA+vXrQ0cRyVpRC13FJXVKzWyv8jdmthtwQLonNLPWZnaFmT1hZi8n//xvM9NstCLVuOOOO7jxxhv5j//4j9BRRLJW1FuXH5vZFGA6iRUIFpnZvOS+c4EV6ZzMzDqSGIz+HRK9MP8NHAycDFxgZgOSC76KSNLmzZuZMWMGkFhvTkSqFrVFdwvQMfmaDnwF3Jp87QJclub5ZgLrgO+6e5677+3uecB3SQxSnxkxp0hs/frXv+Zf//oXhx9+OKeeemroOCJZK1KLzt0XU2Guy2RnkZ4khgusijCt13HA/u6+rdL3vGVmw4BVUXKKxNVXX33FrFmJZR+nTJmCWXVDUEUkaovuGzxhtbsvd/dSM6tx5pQqbKtc5CqcewugNUdEKpgzZw6ff/45Rx99NCeddFLoOCJZLaUWXXIS5nSckubxG81skLv/uYrvPg34Ms3zicRWSUkJN998M6DWnEgqUr11eVea5/XaD/mGacDDZvY3EoPN/w20JzGg/DhgaJrnE4mtvLw8nnjiCR555BEGDhwYOo5I1ku10K0k9VaaAU+kE8LdHzOznwKzgIr3YT4ERrj74+mcTyTu+vfvT//+/UPHEGkUUi10c5LL9KTEzOakG8TdHwAeMLP9gQ7ABnd/J93ziMTZ+vXr6dy5c+gYIo1KSp1R3P23VW03sx+Y2UT/B31MAAARAklEQVQzm5F8/0Mza1vd8Sl+1zvu/mIuFDkzG2xmczdu3Bg6ijQCGzZsoFevXgwaNIgtW7aEjiPSaETqdWlmbc3sGRJDDK4HyjurnAy8aWb5GcgWe+7+uLuPbteuXego0gjcdNNNbNq0iR07dtCqVavQcUQajajDC2YAeSQKWzfgMwB3Hw9ciwZ4i2TUp59+yq9+9SuAnauIi0hqok4B9mMSs5hsAjCzsvId7r7AzK7KRDgRSZg1axYlJSUMHjyYww47LHQckUYlaotue3mRq8ZuEc8rIpX885//5De/SczBMHny5MBpRBqfqIVuc3Jqrm8xs1OAL6JHEpGKbrzxRrZs2cLpp5/OoYemtQKWiBD91uU04CEzewH4f0BHM5tAYhLmwUCVRVBE0teqVStatWql1pxIRJFadO7+MHAWkA+MA/YGppCYyWSEu6c1YFxEqjdr1iw++eQTDj744NBRRBqlyJM6u/sD7t6dxBpyxwLfcfd8d1+YnOVERDJk9913Dx1BpNGq8+oF1QzwvrKu5xXJdVOnTqWoqIgdO3aEjiLSqKX1jM7MWgJHkJhw+VV3/7jS/v4kxtF9N2MJRXLQmjVrmDJlCmVlZRxxxBH07NkzdCSRRivlFl1ytpNlwHPAQmC1mQ1K7jvezJ4HXiDxnE4jWkXqYOrUqZSWlnLOOeeoyInUUTotupnANmAs0By4APiFme0L3Aa8AfwMWODu2zOcUyRnrF69mnvuuYemTZty3XXXhY4j0uilU+gOAw539w0AZvYw8C4wAjjB3Z+th3wiOWfy5MmUlZVx/vnn06NHj9BxRBq9dArdlvIiB+DuxWa2ARhUcbuIRLdy5Uruu+8+mjdvTmFhYeg4IrGQTq/LrVVs+6SqImdmN0SPJJK7brvtNtydUaNGkZ+fHzqOSCyk06LzKraVVbENEpM+F6QfRyS3zZ49mz59+vCTn/wkdBSR2Ein0B1iZpUH9FgV20QkolatWnHZZZeFjiESK+kUun8Dj6VwnAGDosURyU3r1q2jbdu2mgFFpB6kU+jWufu5qRxoZksj5hHJSZdddhnPP/88f/zjHznppJNCxxGJlXQ6o6Tz26ffVJEUFBUVsddee/HYY4/x5ZdfUlxcHDqSSOykXOjc/V/1caxIrioqKmL06NGsX78eAHfn6quvpqioKHAykXip86TOIhJNYWEhJSUl39hWUlKi8XMiGaZCJxLIunXr0touItGo0IkE0qlTpyq3d+vWrYGTiMSbCp1IIJdccglNmnzzVzAvL4/p06cHSiQSTyp0IoFcd9113HPPPXTr1g0zo3v37sydO5cRI0aEjiYSK2ktvCoimTVixAgVNpF6phadSAN7+eWXOeuss1i5cmXoKCI5QYVOpIFNnjyZ+++/n3vuuSd0FJGcoEIn0oBeeeUVnnrqKdq0acPYsWNDxxHJCSp0GWZmV5tZVUsaiTB58mQAfv7zn9OhQ4fAaURyQ6wLnZntZWZPN1ThMbODgAEN8V3S+Lzyyis8+eSTas2JNLDYFjozOx14CdivluP2NLMiM3sn+XrIzPaJ8H3NgenAtdESS9xNmTIFSLTmOnbsGDiNSO6IbaEDxgMnAi9Wd4CZtQCeAVoAfYADgc3Ac2a2S5rfdz1wG/BllLASb2vXruXpp58mLy9PrTmRBhbncXRHu3upmdV0zEigL3C6u5cCmNk44GPgYuCm5LaXgK7VnOPI5L48d3/WzPIzkl5ipXv37qxatYqlS5eqNSfSwGJb6MoLVy2GkVhQdk2Fz603sxXJfTclt/Wv6SRmdhmwu5ndAbRNbrsD+Ju7Pxjxf4LETM+ePenZs2foGCI5J7aFLkV9gXer2P4+cHyqJ3H3ceU/J1t0Z7n7RXUNJ/Hw97//nSOOOIJa7i6ISD3J9ULXAXi9iu1fAnlm1trdv071ZGY2ADg3+fOvgLnu/mY1x44GRkNiFvvFixenl1yy1qZNm3Zez3feeYeLLrqIvn37Mnv2bBW7HFDx+kt2yPVCV51Ifxu5+2JgMYlnf7UdOxeYC9CvXz8fMGBAlK+ULLR48WLKr+ctt9wCwI9+9COOO+64gKmkoVS8/pId4tzrMhUbSD5Tq6QtUJJOa06kstdff53HH3+cvLw8rrrqqtBxRHJWrhe6N4H8KrbvC7zVsFEkbsrHzV1yySXsueeegdOI5K5cL3R/ArpXHBJgZp2A7wALA2WSGHjjjTd47LHHaN26NVdffXXoOCI5LdcL3V0kWm4zzayZmTUBZpDodXl7yGDSuJXPaanWnEh4sS10ZnaTmS0DTku+X5Z8tSg/xt23kZg9ZQewAlgJ7AoMdPdNDZBxsJnN3bhxY31/lTQgd6d///507dpVrTmRLGDummg/tH79+vlrr70WOoZkSHmvu9LSUpo1U8fmXKNelw3DzF53936pHBvbFp1IaCpyItlBv4kiGTR69GiaNWvG4YcfTl5eXug4IoJadCIZs3TpUu68805+97vf8eWXWsRCJFuo0IlkSPm4udNOO43OnTsHTiMi5VToRDJg6dKlPPLII7Rq1YozzzwzdBwRqUCFLiANL4iP8tbcxRdfTPv27QOnEZGKVOgCcvfH3X10u3btQkeROli2bNnO1tw111wTOo6IVKJCJ1JHd911FwAXXXSRns2JZCENLxCpo1tuuYVjjz2Wo446KnQUEamCCp1IHTVp0oRhw4aFjiEi1dCtS5GI3n//fdauXRs6hojUQoVOJKKrr76aXr168cADD4SOIiI1UKELSMMLGq8333yThQsX0qRJE4499tjQcUSkBip0AWl4QeNVPm7uwgsvpEuXLoHTiEhNVOhE0lTemmvZsiXjxo0LHUdEaqFCJ5KmqVOnAomVCtSaE8l+KnQiaXjrrbd46KGH1JoTaUQ0jk4kDa1atWLo0KHss88+7L333qHjiEgKVOhE0tCrVy8WLlxIWVlZ6CgikiLduhSJoEkT/eqINBb6bQ1I4+gaj+XLlzNw4ECWLFkSOoqIpEmFLiCNo2s8pk6dynPPPceDDz4YOoqIpEmFTqQWy5cv58EHH6RFixaMHz8+dBwRSZMKnUgtpk6dirtzwQUXqKelSCOkQidSg7ffflutOZFGToVOpAYVW3P77LNP6DgiEoEKnUg1vvjiC5588km15kQaOQ0YF6lG+/btWbNmDS+++KJacyKNmFp0IjXo0KEDQ4YMCR1DROpAhU6kCn/729/Ytm1b6BgikgEqdCKVrFy5khNPPJGDDjpIxU4kBlToAtIUYNmpvKflCSecQIsWLULHEZE6UqELSFOAZZ9Vq1axYMECmjdvrp6WIjGhQidSQXlrbtSoUXTr1i10HBHJABU6kaRVq1Zx//3307x5c6699trQcUQkQ1ToRJLUmhOJJxU6kaSTTjqJAw44QK05kZhRoRNJGjlyJCtWrFBrTiRmVOhEKjCz0BFEJMNU6CTnXXTRRVx99dVs2LAhdBQRqQcqdJLT3nnnHe68805mz57Npk2bQscRkXqgQic5bdq0aZSVlXHuueeSn58fOo6I1AMVOslZ7777Lvfddx/NmjWjoKAgdBwRqScqdAFprsuw1JoTyQ0qdAFprstw3n33XYqKitSaE8kBKnSSkx5++GHKysr42c9+ptacSMw1Cx1AJIRx48Zx9NFHa3C4SA5QoZOcdcwxx4SOICINQLcuJad88MEHvPHGG6FjiEgDUqGTnDJp0iS+//3vM2fOnNBRRKSBqNBJziguLqaoqIimTZsyaNCg0HFEpIGo0EnsFRUVkZ+fT69evdixYwfHHHMMPXr0CB1LRBqICp3EWlFREaNHj2bt2rU7t73yyisUFRUFTCUiDUmFTmKtsLCQkpKSb2z7+uuvKSwsDJRIRBqaCp3E2rp169LaLiLxo0InsVbdgHANFBfJHSp0EmvTp08nLy/vG9vy8vKYPn16oEQi0tBU6CTWRowYwdy5c+nevTtmRvfu3Zk7dy4jRowIHU1EGoimAJPYGzFihAqbSA5Tiy4grUcnIlL/VOgC0np0IiL1T4VORERiTYVORERiTYVORERiTYVORERiTYVORERiTYVORERiTYVORERizdw9dIacZ2b/AtbWemDmtAPqY5R6Xc+b7udTPT6V42o6Jt19HYANKeQKQdc+vWOi7MvW6x+Xa1/+md3cvWNKR7u7Xjn2AuZm43nT/Xyqx6dyXE3HpLsPeC30Nda1D3Pts/n6x+XaR/mMbl3mpsez9Lzpfj7V41M5rqZjou7LRrr26R2ja1//543y+bQ+o1uXIhlmZq+5e7/QOSQMXf/soxadSObNDR1AgtL1zzJq0YmISKypRSciIrGmQiciIrGmQicSkJm1N7P5ZvZLM7vNzB41s16hc0nDMbPmZnaVmW02s4NC54kjFTqRKpjZXmb2tJnV90PsbsAWd7/M3f8beAaYV8/fKbVowOsPMBp4EchrgO/KSSp0IpWY2enAS8B+tRy3p5kVmdk7yddDZrZPOt/l7svc/dIKm94H9ko/tWRKQ15/AHf/tbu/FDWv1E6FTuTbxgMnkvhXdpXMrAWJ1lcLoA9wILAZeM7MdqnDdw8G7qjD56XuQl5/qQfNQgcQyUJHu3upmdV0zEigL3C6u5cCmNk44GPgYuCm5LaXgK7VnONId/+o/I2ZnUpiDr/Zdf5fIHUR5PpL/VGhE6mk/C+uWgwD1rn7mgqfW29mK5L7bkpu65/KdyaL3BDgbHcvSz+1ZEqI6y/1S7cuRaLpS+J5WmXvAwencyIz+08St8ouTLYkbstAPqlfGbv+Uv9U6ESi6QB8VcX2L4E8M2udyknMrC9wP3Am8E8zW0+iF55kt4xcfwAz+4GZ/Sr5tsDMzshEQPk/unUpklk1PtipzN3fRL+HcZLW9Qdw9yXAEuDnmY8joBadSFQbgLZVbG8LlLj71w2cRxqWrn8jokInEs2bQH4V2/cF3mrYKBKArn8jokInEs2fgO5mll++wcw6Ad8BFgbKJA1H178RUaETieYuEv9yn2lmzcysCTCDRK+720MGkwZxF7r+jYYKnUglZnaTmS0DTku+X5Z8tSg/xt23kRgSsANYAawEdgUGuvumALElQ3T940cLr4qISKypRSciIrGmQiciIrGmQiciIrGmQiciIrGmQiciIrGmQiciIrGmQiciIrGmQiciIrGmQiciIrGmQicimNk8M3MzuyV0FpFM0xRgIjkuuRr2ehJrqf0L2NvdS8OmEskctehE5HQSExLPAvYEfhw2jkhmqdCJyEgSy8tcR6JFd07FnWbW08y2m9nkSttvN7OvzKxfw0UVSZ8KnUgOM7MuwAnAve6+HVgAnGZmu5cf4+7FwDxgjJl1SH5uInAecLq7v9bwyUVSp0InktvOJvH3wL3J9/cALYEzKh03GWgKjDOzUcAk4Gx3/2tDBRWJSp1RRHKYmb0NfOXuR1bYthL4t7sfVenY6cBYoBnw3+7+6wYNKxKRWnQiOcrMDgMOBP5QadcfgP5m1rvS9tUkWnsvqchJY6JCJ5K7RgLbgQcqbb8XcCp0SjGzgcBvgZeAo83suw0VUqSudOtSJAeZWQvgE+BFdx9Sxf7ngB5APnAosJhES28M8C7wtruf2lB5ReqiWegAIhLEIGAP4EMz+0kV+9cAA4DzgWnAIuAydy9LDjP4nZn9wN2XNFRgkajUohPJQWb2KHBaCoc6sAT4kbtvTX62KbCcKjqsiGQjFToREYk1dUYREZFYU6ETEZFYU6ETEZFYU6ETEZFYU6ETEZFYU6ETEZFYU6ETEZFYU6ETEZFYU6ETEZFYU6ETEZFY+/92b6vCHb3tTQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the error versus the grid-spacing size.\n", + "pyplot.figure(figsize=(6.0, 6.0))\n", + "pyplot.grid()\n", + "pyplot.xlabel(r'$\\Delta x$')\n", + "pyplot.ylabel('Relative $L_2$-norm\\nof the error')\n", + "dx_values = L / (numpy.array(nx_values) - 1)\n", + "pyplot.loglog(dx_values, errors,\n", + " color='black', linestyle='--', linewidth=2, marker='o')\n", + "pyplot.axis('equal');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That looks good! See how for each quadrant we go right, the error drops two quadrants going down (and even a bit better!)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Dig deeper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's re-do the spatial convergence, but comparing at a much later time, say $t=1000$." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "dt = 0.1 # time-step size\n", + "t = 1000.0 # final time\n", + "nt = int(t / dt) # number of time steps to compute\n", + "\n", + "# Create a list with the grid-spacing sizes to use.\n", + "nx_values = [11, 21, 41, 81, 161]\n", + "\n", + "# Create an empty list to store the errors.\n", + "errors = []\n", + "\n", + "# Compute the numerical solutions and errors.\n", + "for nx in nx_values:\n", + " dx = L / (nx - 1) # grid spacing\n", + " x = numpy.linspace(0.0, L, num=nx) # grid points\n", + " # Set the initial conditions for the grid.\n", + " T0 = numpy.zeros(nx)\n", + " T0[0] = 100.0\n", + " # Compute the solution using Crank-Nicolson scheme.\n", + " T = crank_nicolson(T0, nt, dt, dx, alpha, q)\n", + " # Compute the analytical solution.\n", + " T_exact = analytical_temperature(x, t, alpha, L, 100)\n", + " # Compute and record the L2-norm of the error.\n", + " errors.append(l2_error(T, T_exact))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the error versus the grid-spacing size.\n", + "pyplot.figure(figsize=(6.0, 6.0))\n", + "pyplot.grid()\n", + "pyplot.xlabel(r'$\\Delta x$')\n", + "pyplot.ylabel('Relative $L_2$-norm\\nof the error')\n", + "dx_values = L / (numpy.array(nx_values) - 1)\n", + "pyplot.loglog(dx_values, errors,\n", + " color='black', linestyle='--', linewidth=2, marker='o')\n", + "pyplot.axis('equal');" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.011922719076357474,\n", + " 0.006181593859790544,\n", + " 0.003142664307189285,\n", + " 0.0015838621626866334,\n", + " 0.0007950070915380142]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "errors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wait, convergence is not that great now! It's not as good as second order, but not as bad as first order. *What is going on?*\n", + "\n", + "Remember our implementation of the boundary conditions? We used\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{T^{n}_{N-1} - T^{n}_{N-2}}{\\Delta x} = q\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Well, that is a **first-order** approximation! \n", + "\n", + "But, why doesn't this affect our solution at an earlier time? Initially, temperature on the right side of the rod is zero and the gradient is very small in that region; at that point in time, errors there were negligible. Once temperature starts picking up, we start having problems.\n", + "\n", + "**Boundary conditions can affect the convergence and accuracy of your solution!**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "###### The cell below loads the style of the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/04_spreadout/04_06_Reaction_Diffusion.ipynb b/2-finite-difference-method/lessons/04_spreadout/04_06_Reaction_Diffusion.ipynb new file mode 100644 index 0000000..26b7d0b --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/04_06_Reaction_Diffusion.ipynb @@ -0,0 +1,576 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, C.D. Cooper, G.F. Forsyth." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Reaction-diffusion model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This Jupyter Notebook presents the context and set-up for the coding assignment of Module 4: _Spreading out: Diffusion problems_, of the course [**\"Practical Numerical Methods with Python\"**](https://github.com/numerical-mooc/numerical-mooc) (a.k.a., numericalmooc).\n", + "\n", + "So far in this module, we've studied diffusion in 1D and 2D. Now it's time to add in some more interesting physics. You'll study a model represented by *reaction-diffusion* equations. What are they? The name says it all—it's a system that has the physics of diffusion but also has some kind of reaction that adds different behaviors to the solution.\n", + "\n", + "We're going to look at the _Gray-Scott model_, which simulates the interaction of two generic chemical species reacting and ... you guessed it ... diffusing! Some amazing patterns can emerge with simple reaction models, eerily reminiscent of patterns formed in nature. It's fascinating! Check out this simulation by Karl Sims posted on You Tube ... it looks like a growing coral reef, doesn't it?" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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\n", + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import YouTubeVideo\n", + "YouTubeVideo('8dTmUr5qKvI')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gray-Scott model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Gray-Scott model represents the reaction and diffusion of two generic chemical species, $U$ and $V$, whose concentration at a point in space is represented by variables $u$ and $v$. The model follows some simple rules. \n", + "\n", + "* Each chemical _diffuses_ through space at its own rate.\n", + "* Species $U$ is added at a constant feed rate into the system.\n", + "* Two units of species V can 'turn' a unit of species U into V: $\\; 2V+U\\rightarrow 3V$\n", + "* There's a constant kill rate removing species $V$.\n", + "\n", + "This model results in the following system of partial differential equations for the concentrations $u(x,y,t)$ and $v(x,y,t)$ of both chemical species:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$\n", + "\\begin{align}\n", + "\\frac{\\partial u}{\\partial t} &= D_u \\nabla ^2 u - uv^2 + F(1-u)\\\\\n", + "\\frac{\\partial v}{\\partial t} &= D_v \\nabla ^2 v + uv^2 - (F + k)v\n", + "\\end{align}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You should see some familiar terms, and some unfamiliar ones. On the left-hand side of each equation, we have the time rate of change of the concentrations. The first term on the right of each equation correspond to the spatial diffusion of each concentration, with $D_u$ and $D_v$ the respective rates of diffusion.\n", + "\n", + "In case you forgot, the operator $\\nabla ^2$ is the Laplacian:\n", + "\n", + "$$\n", + "\\nabla ^2 u = \\frac{\\partial ^2 u}{\\partial x^2} + \\frac{\\partial ^2 u}{\\partial y^2}\n", + "$$\n", + "\n", + "The second term on the right-hand side of each equation corresponds to the reaction. You see that this term decreases $u$ while it increases $v$ in the same amount: $uv^2$. The reaction requires one unit of $U$ and two units of $V$, resulting in a reaction rate proportional to the concentration $u$ and to the square of the concentration $v$. This result derives from the _law of mass action_, which we can explain in terms of probability: the odds of finding one molecule of species $U$ at a point in space is proportional to the concentration $u$, while the odds of finding two molecules of $V$ is proportional to the concentration squared, $v^2$. We assume here a reaction rate constant equal to $1$, which just means that the model is non-dimensionalized in some way.\n", + "\n", + "The final terms in the two equations are the \"feed\" and \"kill\" rates, respectively: $F(1-u)$ replenishes the species $U$ (which would otherwise run out, as it is being turned into $V$ by the reaction); $-(F+k)v$ is diminishing the species $V$ (otherwise the concentration $v$ would simply increase without bound). \n", + "\n", + "The values of $F$ and $k$ are chosen parameters and part of the fun of this assignment is to change these values, together with the diffusion constants, and see what happens. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The system is represented by two arrays, `U` and `V`, holding the discrete values of the concentrations $u$ and $v$, respectively. We start by setting `U = 1` everywhere and `V = 0` everywhere, then introduce areas of difference, as initial conditions. We then add a little noise to the whole system to help the $u$ and $v$ reactions along. \n", + "\n", + "Below is the code segment we used to generate the initial conditions for `U` and `V`. \n", + "\n", + "**NOTE**: *DO NOT USE THIS CODE IN YOUR ASSIGNMENT*.\n", + "We are showing it here to help you understand how the system is constructed. However, you _must use the data we've supplied below_ as your starting condition or your answers will not match those that the grading system expects.\n", + "\n", + "```[Python]\n", + "num_blocks = 30\n", + "randx = numpy.random.randint(1, nx - 1, num_blocks)\n", + "randy = numpy.random.randint(1, nx - 1, num_blocks)\n", + "U = numpy.ones((n, n))\n", + "V = numpy.zeros((n, n))\n", + "\n", + "r = 10\n", + "U[:, :] = 1.0\n", + "\n", + "for i, j in zip(randx, randy):\n", + " U[i - r:i + r, j - r:j + r] = 0.50\n", + " V[i - r:i + r, j - r:j + r] = 0.25\n", + "\n", + "U += 0.05 * numpy.random.random((n, n))\n", + "V += 0.05 * numpy.random.random((n, n))\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Your assignment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Discretize the reaction-diffusion equations using forward-time/central-space and assume that $\\Delta x = \\Delta y = \\delta$.\n", + "\n", + "* For your time step, set \n", + "$$\n", + "\\Delta t = \\frac{9}{40}\\frac{\\delta^2}{\\max(D_u, D_v)}\n", + "$$\n", + "\n", + "* Use zero Neumann boundary conditions on all sides of the domain.\n", + "\n", + "You should use the initial conditions and constants listed in the cell below. They correspond to the following domain:\n", + "\n", + "* Grid of points with dimension `192x192` points\n", + "* Domain is $5{\\rm m} \\times 5{\\rm m}$\n", + "* Final time is $8000{\\rm s}$." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot, cm\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set spatial parameters.\n", + "Lx, Ly = 5.0, 5.0 # domain dimensions\n", + "nx, ny = 192, 192 # number of points in each direction\n", + "dx, dy = Lx / (nx - 1), Ly / (ny - 1) # grid spacings\n", + "\n", + "# Set parameters of the pattern.\n", + "Du, Dv = 0.00016, 0.00008 # rates of diffusion\n", + "F, k = 0.035, 0.065 # parameters to feed and kill\n", + "\n", + "# Set temporal parameters.\n", + "t = 8000.0 # final time\n", + "dt = 9.0 * dx**2 / (40.0 * max(Du, Dv)) # time-step size\n", + "nt = int(t / dt) # number of time steps to compute" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initial condition data files" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to ensure that you start from the same initial conditions as we do, please download the file [uvinitial.npz](https://github.com/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/data/uvinitial.npz?raw=true) or execute the following code cell (it will download the file using the `urllib.request` module)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import urllib.request\n", + "\n", + "# Download and read the data file.\n", + "url = ('https://github.com/numerical-mooc/numerical-mooc/blob/master/'\n", + " 'lessons/04_spreadout/data/uvinitial.npz?raw=true')\n", + "filepath = 'uvinitial.npz'\n", + "urllib.request.urlretrieve(url, filepath);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a NumPy save-file that contains two NumPy arrays, holding the initial values for `U` and `V`, respectively. Once you have downloaded the file into your working directory, you can load the data using the following code snippet. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Read the initial fields from the file.\n", + "uvinitial = numpy.load(filepath)\n", + "u0, v0 = uvinitial['U'], uvinitial['V']" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the initial fields.\n", + "fig, ax = pyplot.subplots(ncols=2, figsize=(9.0, 4.0))\n", + "ax[0].imshow(u0, cmap=cm.RdBu)\n", + "ax[0].axis('off')\n", + "ax[1].imshow(v0, cmap=cm.RdBu)\n", + "ax[1].axis('off');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sample Solution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below is an animated gif showing the results of this solution for a different set of randomized initial block positions. Each frame of the animation represents 100 time steps. \n", + "\n", + "Just to get your juices flowing!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exploring extra patterns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you have completed the assignment, you might want to explore a few more of the interesting patterns that can be obtained with the Gray-Scott model. The conditions below will result in a variety of patterns and should work without any other changes to your existing code.\n", + "\n", + "This pattern is called \"Fingerprints.\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "#Du, Dv, F, k = 0.00014, 0.00006, 0.035, 0.065 # Bacteria 2\n", + "#Du, Dv, F, k = 0.00016, 0.00008, 0.060, 0.062 # Coral\n", + "#Du, Dv, F, k = 0.00019, 0.00005, 0.060, 0.062 # Fingerprint\n", + "#Du, Dv, F, k = 0.00010, 0.00010, 0.018, 0.050 # Spirals\n", + "#Du, Dv, F, k = 0.00012, 0.00008, 0.020, 0.050 # Spirals Dense\n", + "#Du, Dv, F, k = 0.00010, 0.00016, 0.020, 0.050 # Spirals Fast\n", + "#Du, Dv, F, k = 0.00016, 0.00008, 0.020, 0.055 # Unstable\n", + "#Du, Dv, F, k = 0.00016, 0.00008, 0.050, 0.065 # Worms 1\n", + "#Du, Dv, F, k = 0.00016, 0.00008, 0.054, 0.063 # Worms 2\n", + "#Du, Dv, F, k = 0.00016, 0.00008, 0.035, 0.060 # Zebrafish" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Reaction-diffusion tutorial, by Karl Sims\n", + "http://www.karlsims.com/rd.html\n", + "\n", + "* Pearson, J. E. (1993). [Complex patterns in a simple system](http://www.sciencemag.org/content/261/5118/189), _Science_, Vol. 261(5118), 189-192 // [PDF](http://www3.nd.edu/~powers/pearson.pdf) from nd.edu.\n", + "\n", + "* Pattern Parameters from [http://www.aliensaint.com/uo/java/rd/](http://www.aliensaint.com/uo/java/rd/)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "###### The cell below loads the style of the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/04_spreadout/README.md b/2-finite-difference-method/lessons/04_spreadout/README.md new file mode 100644 index 0000000..0699f2e --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/README.md @@ -0,0 +1,43 @@ +# Module 4: +## Spreading out: diffusion problems +## Summary +This module focuses on solution of parabolic PDEs, like the diffusion equation. It introduces for the first time implicit methods and covers both one- and two-dimensional problems. + +* [Lesson 1](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_01_Heat_Equation_1D_Explicit.ipynb) develops a 1D heat-conduction problem and its solution by means of a forward-time/centered-space scheme. It discusses in detail Dirichlet and Neumann boundary conditions, looking at their implementation in code. At the end, it touches on boundary condition and time step limits with explicit schemes. + +* [Lesson 2](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_02_Heat_Equation_1D_Implicit.ipynb) introduces implicit schemes for the first time: it develops the implicit discretization of the 1D heat equation and discusses boundary conditions in detail. + +* In [lesson 3](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_03_Heat_Equation_2D_Explicit.ipynb) we graduate to two dimensions! A 2D heat-conduction problem is described, representing a computer microchip, and is solved with an explicit scheme. The lesson covers boundary conditions in 2D and array-storage decisions. + +* [Lesson 4](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_04_Heat_Equation_2D_Implicit.ipynb) develops the implicit solution of 2D heat conduction, explaining in detail how to construct the coefficient matrix and the various combinations of boundary conditions. + +* [Lesson 5](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_05_Crank-Nicolson.ipynb) is dedicated to the Crank-Nicolson scheme, including a study of spatial and time accuracy and convergence. +* [Coding assignment](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_06_Reaction_Diffusion.ipynb) Reaction-diffusion with the Gray-Scott model in 2D. + +## Badge earning +Completion of this module in the online course platform can earn the learner the Module 4 badge. + +### Description: What does this badge represent? +The earner completed Module 4 of the course "Practical Numerical Methods with Python" (a.k.a., numericalmooc). + +### Criteria: What needs to be done to earn it? +To earn this badge, the learner needs to complete the graded assessment in the course platform including: answering quiz +questions about handling boundary conditions, and completing the individual coding assignment on the Gray-Scott model of reaction-diffusion and answering the numeric questions online. +Earners should also have completed self-study of the five module lessons, by reading, reflecting on and writing their own version of the codes. This is not directly assessed, but it is assumed. Thus, earners are encouraged to provide evidence of this self-study by giving links to their code repositories or other learning objects they created in the process. + +### Evidence: Website (link to original digital content) +Desirable: link to the earner's GitHub repository (or equivalent) containing the solution to the "Reaction-Diffusion" coding assignment. Optional: link to the earner's GitHub repository (or equivalent) containing other codes, following the lesson. + +### Category: +Higher education, graduate + +### Tags: +engineering, computation, higher education, numericalmooc, python, gwu, george washington university, lorena barba, github + +### Relevant Links: Is there more information on the web? + +[Course About page](http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/about) + +[Course wiki](http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/wiki/GW.MAE6286.2014_fall/) + +[Course GitHub repo](https://github.com/numerical-mooc/numerical-mooc) diff --git a/2-finite-difference-method/lessons/04_spreadout/data/uvinitial.npz b/2-finite-difference-method/lessons/04_spreadout/data/uvinitial.npz new file mode 100644 index 0000000..bd6ccb0 Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/data/uvinitial.npz differ diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/2D_discretization.png b/2-finite-difference-method/lessons/04_spreadout/figures/2D_discretization.png new file mode 100644 index 0000000..11e9244 Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/figures/2D_discretization.png differ diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/2d_stencil.svg b/2-finite-difference-method/lessons/04_spreadout/figures/2d_stencil.svg new file mode 100644 index 0000000..ab03273 --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/figures/2d_stencil.svg @@ -0,0 +1,771 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/2dchip.svg b/2-finite-difference-method/lessons/04_spreadout/figures/2dchip.svg new file mode 100644 index 0000000..5fc7faf --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/figures/2dchip.svg @@ -0,0 +1,993 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/2dgrid.svg b/2-finite-difference-method/lessons/04_spreadout/figures/2dgrid.svg new file mode 100644 index 0000000..8277706 --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/figures/2dgrid.svg @@ -0,0 +1,979 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/2dgrid_indices.svg b/2-finite-difference-method/lessons/04_spreadout/figures/2dgrid_indices.svg new file mode 100644 index 0000000..7146274 --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/figures/2dgrid_indices.svg @@ -0,0 +1,450 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/A_1.svg b/2-finite-difference-method/lessons/04_spreadout/figures/A_1.svg new file mode 100644 index 0000000..840f9c4 --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/figures/A_1.svg @@ -0,0 +1,503 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/A_2.svg b/2-finite-difference-method/lessons/04_spreadout/figures/A_2.svg new file mode 100644 index 0000000..432488e --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/figures/A_2.svg @@ -0,0 +1,542 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/A_3.svg b/2-finite-difference-method/lessons/04_spreadout/figures/A_3.svg new file mode 100644 index 0000000..21dbaf5 --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/figures/A_3.svg @@ -0,0 +1,428 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/btcs_stencil.png b/2-finite-difference-method/lessons/04_spreadout/figures/btcs_stencil.png new file mode 100644 index 0000000..e4419ab Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/figures/btcs_stencil.png differ diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/celldivision.gif b/2-finite-difference-method/lessons/04_spreadout/figures/celldivision.gif new file mode 100644 index 0000000..b9c4273 Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/figures/celldivision.gif differ diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/explicitFTCS-BCeffect.png b/2-finite-difference-method/lessons/04_spreadout/figures/explicitFTCS-BCeffect.png new file mode 100644 index 0000000..3667973 Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/figures/explicitFTCS-BCeffect.png differ diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/fingerprint.gif b/2-finite-difference-method/lessons/04_spreadout/figures/fingerprint.gif new file mode 100644 index 0000000..eef8ba3 Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/figures/fingerprint.gif differ diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/graphite-rod.png b/2-finite-difference-method/lessons/04_spreadout/figures/graphite-rod.png new file mode 100644 index 0000000..62203eb Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/figures/graphite-rod.png differ diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/implicit-matrix-blocks.png b/2-finite-difference-method/lessons/04_spreadout/figures/implicit-matrix-blocks.png new file mode 100644 index 0000000..f58105c Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/figures/implicit-matrix-blocks.png differ diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/implicit_formula.png b/2-finite-difference-method/lessons/04_spreadout/figures/implicit_formula.png new file mode 100644 index 0000000..cf7ece9 Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/figures/implicit_formula.png differ diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/implicit_formula.svg b/2-finite-difference-method/lessons/04_spreadout/figures/implicit_formula.svg new file mode 100644 index 0000000..b896e46 --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/figures/implicit_formula.svg @@ -0,0 +1,637 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/implicit_matrix.svg b/2-finite-difference-method/lessons/04_spreadout/figures/implicit_matrix.svg new file mode 100644 index 0000000..89bbb67 --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/figures/implicit_matrix.svg @@ -0,0 +1,936 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/matrix-blocks-on-grid.png b/2-finite-difference-method/lessons/04_spreadout/figures/matrix-blocks-on-grid.png new file mode 100644 index 0000000..27fe9d7 Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/figures/matrix-blocks-on-grid.png differ diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/rowcolumn.svg b/2-finite-difference-method/lessons/04_spreadout/figures/rowcolumn.svg new file mode 100644 index 0000000..51db84c --- /dev/null +++ b/2-finite-difference-method/lessons/04_spreadout/figures/rowcolumn.svg @@ -0,0 +1,554 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/stencil-cranknicolson.png b/2-finite-difference-method/lessons/04_spreadout/figures/stencil-cranknicolson.png new file mode 100644 index 0000000..3186ae4 Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/figures/stencil-cranknicolson.png differ diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/stencil-implicitcentral.png b/2-finite-difference-method/lessons/04_spreadout/figures/stencil-implicitcentral.png new file mode 100644 index 0000000..51b077f Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/figures/stencil-implicitcentral.png differ diff --git a/2-finite-difference-method/lessons/04_spreadout/figures/stencil-weights.png b/2-finite-difference-method/lessons/04_spreadout/figures/stencil-weights.png new file mode 100644 index 0000000..995d9fd Binary files /dev/null and b/2-finite-difference-method/lessons/04_spreadout/figures/stencil-weights.png differ diff --git a/2-finite-difference-method/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb b/2-finite-difference-method/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb new file mode 100644 index 0000000..768c595 --- /dev/null +++ b/2-finite-difference-method/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb @@ -0,0 +1,1217 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license © 2015 L.A. Barba, C.D. Cooper, G.F. Forsyth. Based on [CFD Python](https://github.com/barbagroup/CFDPython), © 2013 L.A. Barba, also under CC-BY license." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Relax and hold steady" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is **Module 5** of the open course [**\"Practical Numerical Methods with Python\"**](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about), titled *\"Relax and hold steady: elliptic problems\"*. \n", + "If you've come this far in the [#numericalmooc](https://twitter.com/hashtag/numericalmooc) ride, it's time to stop worrying about **time** and relax. \n", + "\n", + "So far, you've learned to solve problems dominated by convection—where solutions have a directional bias and can form shocks—in [Module 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/tree/master/lessons/03_wave/): *\"Riding the Wave.\"* In [Module 4](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/tree/master/lessons/04_spreadout/) (*\"Spreading Out\"*), we explored diffusion-dominated problems—where solutions spread in all directions. But what about situations where solutions are steady?\n", + "\n", + "Many problems in physics have no time dependence, yet are rich with physical meaning: the gravitational field produced by a massive object, the electrostatic potential of a charge distribution, the displacement of a stretched membrane and the steady flow of fluid through a porous medium ... all these can be modeled by **Poisson's equation**:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla^2 u = f\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where the unknown $u$ and the known $f$ are functions of space, in a domain $\\Omega$. To find the solution, we require boundary conditions. These could be Dirichlet boundary conditions, specifying the value of the solution on the boundary,\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u = b_1 \\text{ on } \\partial\\Omega,\n", + "\\end{equation}\n", + "$$\n", + "\n", + "or Neumann boundary conditions, specifying the normal derivative of the solution on the boundary,\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial u}{\\partial n} = b_2 \\text{ on } \\partial\\Omega.\n", + "\\end{equation}\n", + "$$\n", + "\n", + "A boundary-value problem consists of finding $u$, given the above information. Numerically, we can do this using *relaxation methods*, which start with an initial guess for $u$ and then iterate towards the solution. Let's find out how!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Laplace's equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The particular case of $f=0$ (homogeneous case) results in Laplace's equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla^2 u = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "For example, the equation for steady, two-dimensional heat conduction is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial ^2 T}{\\partial x^2} + \\frac{\\partial ^2 T}{\\partial y^2} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This is similar to the model we studied in [lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_03_Heat_Equation_2D_Explicit.ipynb) of **Module 4**, but without the time derivative: i.e., for a temperature $T$ that has reached steady state. The Laplace equation models the equilibrium state of a system under the supplied boundary conditions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The study of solutions to Laplace's equation is called *potential theory*, and the solutions themselves are often potential fields. Let's use $p$ from now on to represent our generic dependent variable, and write Laplace's equation again (in two dimensions):\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial ^2 p}{\\partial x^2} + \\frac{\\partial ^2 p}{\\partial y^2} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Like in the diffusion equation of the previous course module, we discretize the second-order derivatives with *central differences*. You should be able to write down a second-order central-difference formula by heart now! On a two-dimensional Cartesian grid, it gives:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{p_{i+1, j} - 2p_{i,j} + p_{i-1,j} }{\\Delta x^2} + \\frac{p_{i,j+1} - 2p_{i,j} + p_{i, j-1} }{\\Delta y^2} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "When $\\Delta x = \\Delta y$, we end up with the following equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p_{i+1, j} + p_{i-1,j} + p_{i,j+1} + p_{i, j-1}- 4 p_{i,j} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This tells us that the Laplacian differential operator at grid point $(i,j)$ can be evaluated discretely using the value of $p$ at that point (with a factor $-4$) and the four neighboring points to the left and right, above and below grid point $(i,j)$.\n", + "\n", + "The stencil of the discrete Laplacian operator is shown in Figure 1. It is typically called the *five-point stencil*, for obvious reasons." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Figure 1: Laplace five-point stencil." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The discrete equation above is valid for every interior point in the domain. If we write the equations for *all* interior points, we have a linear system of algebraic equations. We *could* solve the linear system directly (e.g., with Gaussian elimination), but we can be more clever than that!\n", + "\n", + "Notice that the coefficient matrix of such a linear system has mostly zeroes. For a uniform spatial grid, the matrix is *block diagonal*: it has diagonal blocks that are tridiagonal with $-4$ on the main diagonal and $1$ on two off-center diagonals, and two more diagonals with $1$. All of the other elements are zero. Iterative methods are particularly suited for a system with this structure, and save us from storing all those zeroes.\n", + "\n", + "We will start with an initial guess for the solution, $p_{i,j}^{0}$, and use the discrete Laplacian to get an update, $p_{i,j}^{1}$, then continue on computing $p_{i,j}^{k}$ until we're happy. Note that $k$ is _not_ a time index here, but an index corresponding to the number of iterations we perform in the *relaxation scheme*. \n", + "\n", + "At each iteration, we compute updated values $p_{i,j}^{k+1}$ in a (hopefully) clever way so that they converge to a set of values satisfying Laplace's equation. The system will reach equilibrium only as the number of iterations tends to $\\infty$, but we can approximate the equilibrium state by iterating until the change between one iteration and the next is *very* small. \n", + "\n", + "The most intuitive method of iterative solution is known as the [**Jacobi method**](https://en.wikipedia.org/wiki/Jacobi_method), in which the values at the grid points are replaced by the corresponding weighted averages:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p^{k+1}_{i,j} = \\frac{1}{4} \\left(p^{k}_{i,j-1} + p^k_{i,j+1} + p^{k}_{i-1,j} + p^k_{i+1,j} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This method does indeed converge to the solution of Laplace's equation. Thank you Professor Jacobi!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Challenge task\n", + "\n", + "Grab a piece of paper and write out the coefficient matrix for a discretization with 7 grid points in the $x$ direction (5 interior points) and 5 points in the $y$ direction (3 interior). The system should have 15 unknowns, and the coefficient matrix three diagonal blocks. Assume prescribed Dirichlet boundary conditions on all sides (not necessarily zero)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Boundary conditions and relaxation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Suppose we want to model steady-state heat transfer on (say) a computer chip with one side insulated (zero Neumann BC), two sides held at a fixed temperature (Dirichlet condition) and one side touching a component that has a sinusoidal distribution of temperature.\n", + "We would need to solve Laplace's equation with boundary conditions like\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{gathered}\n", + "p=0 \\text{ at } x=0\\\\\n", + "\\frac{\\partial p}{\\partial x} = 0 \\text{ at } x = L_x\\\\\n", + "p = 0 \\text{ at }y = 0 \\\\\n", + "p = \\sin \\left( \\frac{\\frac{3}{2}\\pi x}{L_x} \\right) \\text{ at } y = L_y\n", + " \\end{gathered}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We'll take $L_x=1$ and $L_y=1$ for the sizes of the domain in the $x$ and $y$ directions.\n", + "\n", + "One of the defining features of elliptic PDEs is that they are \"driven\" by the boundary conditions. In the iterative solution of Laplace's equation, boundary conditions are set and **the solution relaxes** from an initial guess to join the boundaries together smoothly, given those conditions. Our initial guess will be $p=0$ everywhere. Now, let's relax!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we import our usual smattering of libraries (plus a few new ones!)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To visualize 2D data, we can use [`pyplot.imshow()`](http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.imshow), like we've done before, but a 3D plot can sometimes show a more intuitive view the solution. Or it's just prettier!\n", + "\n", + "Be sure to enjoy the many examples of 3D plots in the `mplot3d` section of the [Matplotlib Gallery](http://matplotlib.org/gallery.html#mplot3d). \n", + "\n", + "We'll import the `mplot3d` module to create 3D plots and also grab the `cm` package, which provides different colormaps for visualizing plots. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from mpl_toolkits import mplot3d\n", + "from matplotlib import cm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's define a function for setting up our plotting environment, to avoid repeating this set-up over and over again. It will save us some typing.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_3d(x, y, p, label='$z$', elev=30.0, azim=45.0):\n", + " \"\"\"\n", + " Creates a Matplotlib figure with a 3D surface plot\n", + " of the scalar field p.\n", + "\n", + " Parameters\n", + " ----------\n", + " x : numpy.ndarray\n", + " Gridline locations in the x direction as a 1D array of floats.\n", + " y : numpy.ndarray\n", + " Gridline locations in the y direction as a 1D array of floats.\n", + " p : numpy.ndarray\n", + " Scalar field to plot as a 2D array of floats.\n", + " label : string, optional\n", + " Axis label to use in the third direction;\n", + " default: 'z'.\n", + " elev : float, optional\n", + " Elevation angle in the z plane;\n", + " default: 30.0.\n", + " azim : float, optional\n", + " Azimuth angle in the x,y plane;\n", + " default: 45.0.\n", + " \"\"\"\n", + " fig = pyplot.figure(figsize=(8.0, 6.0))\n", + " ax = mplot3d.Axes3D(fig)\n", + " ax.set_xlabel('$x$')\n", + " ax.set_ylabel('$y$')\n", + " ax.set_zlabel(label)\n", + " X, Y = numpy.meshgrid(x, y)\n", + " ax.plot_surface(X, Y, p, cmap=cm.viridis)\n", + " ax.set_xlim(x[0], x[-1])\n", + " ax.set_ylim(y[0], y[-1])\n", + " ax.view_init(elev=elev, azim=azim)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [] + }, + "source": [ + "##### Note \n", + "This plotting function uses *Viridis*, a new (and _awesome_) colormap available in Matplotlib versions 1.5 and greater. If you see an error when you try to plot using `cm.viridis`, just update Matplotlib using `conda` or `pip`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Analytical solution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Laplace equation with the boundary conditions listed above has an analytical solution, given by\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p(x,y) = \\frac{\\sinh \\left( \\frac{\\frac{3}{2} \\pi y}{L_y}\\right)}{\\sinh \\left( \\frac{\\frac{3}{2} \\pi L_y}{L_x}\\right)} \\sin \\left( \\frac{\\frac{3}{2} \\pi x}{L_x} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $L_x$ and $L_y$ are the length of the domain in the $x$ and $y$ directions, respectively." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We previously used `numpy.meshgrid` to plot our 2D solutions to the heat equation in Module 4. Here, we'll use it again as a plotting aid. Always useful, `linspace` creates 1-row arrays of equally spaced numbers: it helps for defining $x$ and $y$ axes in line plots, but now we want the analytical solution plotted for every point in our domain. To do this, we'll use in the analytical solution the 2D arrays generated by `numpy.meshgrid`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def laplace_solution(x, y, Lx, Ly):\n", + " \"\"\"\n", + " Computes and returns the analytical solution of the Laplace equation\n", + " on a given two-dimensional Cartesian grid.\n", + "\n", + " Parameters\n", + " ----------\n", + " x : numpy.ndarray\n", + " The gridline locations in the x direction\n", + " as a 1D array of floats.\n", + " y : numpy.ndarray\n", + " The gridline locations in the y direction\n", + " as a 1D array of floats.\n", + " Lx : float\n", + " Length of the domain in the x direction.\n", + " Ly : float\n", + " Length of the domain in the y direction.\n", + "\n", + " Returns\n", + " -------\n", + " p : numpy.ndarray\n", + " The analytical solution as a 2D array of floats.\n", + " \"\"\"\n", + " X, Y = numpy.meshgrid(x, y)\n", + " p = (numpy.sinh(1.5 * numpy.pi * Y / Ly) /\n", + " numpy.sinh(1.5 * numpy.pi * Ly / Lx) *\n", + " numpy.sin(1.5 * numpy.pi * X / Lx))\n", + " return p" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ok, let's try out the analytical solution and use it to test the `plot_3D` function we wrote above. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set parameters.\n", + "Lx = 1.0 # domain length in the x direction\n", + "Ly = 1.0 # domain length in the y direction\n", + "nx = 41 # number of points in the x direction\n", + "ny = 41 # number of points in the y direction\n", + "\n", + "# Create the gridline locations.\n", + "x = numpy.linspace(0.0, Lx, num=nx)\n", + "y = numpy.linspace(0.0, Ly, num=ny)\n", + "\n", + "# Compute the analytical solution.\n", + "p_exact = laplace_solution(x, y, Lx, Ly)\n", + "\n", + "# Plot the analytical solution.\n", + "plot_3d(x, y, p_exact)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It worked! This is what the solution *should* look like when we're 'done' relaxing. (And isn't viridis a cool colormap?) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### How long do we iterate?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We noted above that there is no time dependence in the Laplace equation. So it doesn't make a lot of sense to use a `for` loop with `nt` iterations, like we've done before.\n", + "\n", + "Instead, we can use a `while` loop that continues to iteratively apply the relaxation scheme until the difference between two successive iterations is small enough. \n", + "\n", + "But how small is small enough? That's a good question. We'll try to work that out as we go along. \n", + "\n", + "To compare two successive potential fields ($\\mathbf{p}^k$ and $\\mathbf{p}^{k+1}$), a good option is to use the [L2 norm](http://en.wikipedia.org/wiki/Norm_%28mathematics%29#Euclidean_norm) of the difference. It's defined as\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\parallel \\mathbf{p}^{k+1} - \\mathbf{p}^k \\parallel_{L_2} = \\sqrt{\\sum_{i, j} \\left| p_{i, j}^{k+1} - p_{i, j}^k \\right|^2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "But there's one flaw with this formula. We are summing the difference between successive iterations at each point on the grid. So what happens when the grid grows? (For example, if we're refining the grid, for whatever reason.) There will be more grid points to compare and so more contributions to the sum. The norm will be a larger number just because of the grid size!\n", + "\n", + "That doesn't seem right. We'll fix it by normalizing the norm, dividing the above formula by the norm of the potential field at iteration $k$. \n", + "\n", + "For two successive iterations, the relative L2 norm is then calculated as\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\frac{\\parallel \\mathbf{p}^{k+1} - \\mathbf{p}^k \\parallel_{L_2}}{\\parallel \\mathbf{p}^k \\parallel_{L_2}} = \\frac{\\sqrt{\\sum_{i, j} \\left| p_{i, j}^{k+1} - p_{i, j}^k \\right|^2}}{\\sqrt{\\sum_{i, j} \\left| p_{i, j}^k \\right|^2}}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "For this purpose, we define the `l2_norm` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def l2_norm(p, p_ref):\n", + " \"\"\"\n", + " Computes and returns the relative L2-norm of the difference\n", + " between a solution p and a reference solution p_ref.\n", + "\n", + " Parameters\n", + " ----------\n", + " p : numpy.ndarray\n", + " The solution as an array of floats.\n", + " p_ref : numpy.ndarray\n", + " The reference solution as an array of floats.\n", + "\n", + " Returns\n", + " -------\n", + " diff : float\n", + " The relative L2-norm of the difference.\n", + " \"\"\"\n", + " l2_diff = (numpy.sqrt(numpy.sum((p - p_ref)**2)) /\n", + " numpy.sqrt(numpy.sum(p_ref**2)))\n", + " return l2_diff" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's define a function that will apply Jacobi's method for Laplace's equation. Three of the boundaries are Dirichlet boundaries and so we can simply leave them alone. Only the Neumann boundary needs to be explicitly calculated at each iteration. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def laplace_2d_jacobi(p0, maxiter=20000, rtol=1e-6):\n", + " \"\"\"\n", + " Solves the 2D Laplace equation using Jacobi relaxation method.\n", + "\n", + " The function assumes Dirichlet condition with value zero\n", + " at all boundaries except at the right boundary where it uses\n", + " a zero-gradient Neumann condition.\n", + " The exit criterion of the solver is based on the relative L2-norm\n", + " of the solution difference between two consecutive iterations.\n", + "\n", + " Parameters\n", + " ----------\n", + " p0 : numpy.ndarray\n", + " The initial solution as a 2D array of floats.\n", + " maxiter : integer, optional\n", + " Maximum number of iterations to perform;\n", + " default: 20000.\n", + " rtol : float, optional\n", + " Relative tolerance for convergence;\n", + " default: 1e-6.\n", + "\n", + " Returns\n", + " -------\n", + " p : numpy.ndarray\n", + " The solution after relaxation as a 2D array of floats.\n", + " ite : integer\n", + " The number of iterations performed.\n", + " diff : float\n", + " The final relative L2-norm of the difference.\n", + " \"\"\"\n", + " p = p0.copy()\n", + " diff = rtol + 1.0 # initial difference\n", + " ite = 0 # iteration index\n", + " while diff > rtol and ite < maxiter:\n", + " pn = p.copy()\n", + " # Update the solution at interior points.\n", + " p[1:-1, 1:-1] = 0.25 * (p[1:-1, :-2] + p[1:-1, 2:] +\n", + " p[:-2, 1:-1] + p[2:, 1:-1])\n", + " # Apply Neumann condition (zero-gradient)\n", + " # at the right boundary.\n", + " p[1:-1, -1] = p[1:-1, -2]\n", + " # Compute the residual as the L2-norm of the difference.\n", + " diff = l2_norm(p, pn)\n", + " ite += 1\n", + " return p, ite, diff" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Rows and columns, and index order\n", + "\n", + "Recall that in the [2D explicit heat equation](http://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/04_spreadout/04_03_Heat_Equation_2D_Explicit.ipynb) we stored data with the $y$ coordinates corresponding to the rows of the array and $x$ coordinates on the columns (this is just a code design decision!). We did that so that a plot of the 2D-array values would have the natural ordering, corresponding to the physical domain ($y$ coordinate in the vertical). \n", + "\n", + "We'll follow the same convention here (even though we'll be plotting in 3D, so there's no real reason), just to be consistent. Thus, $p_{i,j}$ will be stored in array format as `p[j,i]`. Don't be confused by this." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Let's relax!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The initial values of the potential field are zero everywhere (initial guess), except at the top boundary: \n", + "\n", + "$$\n", + "p = \\sin \\left( \\frac{\\frac{3}{2}\\pi x}{L_x} \\right) \\text{ at } y=L_y\n", + "$$\n", + "\n", + "To initialize the domain, `numpy.zeros` will handle everything except that one Dirichlet condition. Let's do it!" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the initial conditions.\n", + "p0 = numpy.zeros((ny, nx))\n", + "p0[-1, :] = numpy.sin(1.5 * numpy.pi * x / Lx)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's visualize the initial conditions using the `plot_3D` function, just to check we've got it right.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the initial conditions.\n", + "plot_3d(x, y, p0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `p` array is equal to zero everywhere, except along the boundary $y = 1$. Hopefully you can see how the relaxed solution and this initial condition are related. \n", + "\n", + "Now, run the iterative solver with a target L2-norm difference between successive iterations of $10^{-8}$." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jacobi relaxation: 4473 iterations to reach a relative difference of 9.989253685041417e-09\n" + ] + } + ], + "source": [ + "# Compute the solution using Jacobi relaxation method.\n", + "p, ites, diff = laplace_2d_jacobi(p0, rtol=1e-8)\n", + "print('Jacobi relaxation: {} iterations '.format(ites) +\n", + " 'to reach a relative difference of {}'.format(diff))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's make a gorgeous plot of the final field using the newly minted `plot_3d` function." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the numerical solution.\n", + "plot_3d(x, y, p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Awesome! That looks pretty good. But we'll need more than a simple visual check, though. The \"eyeball metric\" is very forgiving!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Convergence analysis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Convergence, Take 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We want to make sure that our Jacobi function is working properly. Since we have an analytical solution, what better way than to do a grid-convergence analysis? We will run our solver for several grid sizes and look at how fast the L2 norm of the difference between consecutive iterations decreases." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now run Jacobi's method on the Laplace equation using four different grids, with the same exit criterion of $10^{-8}$ each time. Then, we look at the error versus the grid size in a log-log plot. What do we get?" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# List of the grid sizes to investigate.\n", + "nx_values = [11, 21, 41, 81]\n", + "\n", + "# Create an empty list to record the error on each grid.\n", + "errors = []\n", + "\n", + "# Compute the solution and error for each grid size.\n", + "for nx in nx_values:\n", + " ny = nx # same number of points in all directions.\n", + " # Create the gridline locations.\n", + " x = numpy.linspace(0.0, Lx, num=nx)\n", + " y = numpy.linspace(0.0, Ly, num=ny)\n", + " # Set the initial conditions.\n", + " p0 = numpy.zeros((ny, nx))\n", + " p0[-1, :] = numpy.sin(1.5 * numpy.pi * x / Lx)\n", + " # Relax the solution.\n", + " # We do not return the number of iterations or\n", + " # the final relative L2-norm of the difference.\n", + " p, _, _ = laplace_2d_jacobi(p0, rtol=1e-8)\n", + " # Compute the analytical solution.\n", + " p_exact = laplace_solution(x, y, Lx, Ly)\n", + " # Compute and record the relative L2-norm of the error.\n", + " errors.append(l2_norm(p, p_exact))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the error versus the grid-spacing size.\n", + "pyplot.figure(figsize=(6.0, 6.0))\n", + "pyplot.xlabel(r'$\\Delta x$')\n", + "pyplot.ylabel('Relative $L_2$-norm\\nof the error')\n", + "pyplot.grid()\n", + "dx_values = Lx / (numpy.array(nx_values) - 1)\n", + "pyplot.loglog(dx_values, errors,\n", + " color='black', linestyle='--', linewidth=2, marker='o')\n", + "pyplot.axis('equal');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hmm. That doesn't look like 2nd-order convergence, but we're using second-order finite differences. *What's going on?* The culprit is the boundary conditions. Dirichlet conditions are order-agnostic (a set value is a set value), but the scheme we used for the Neumann boundary condition is 1st-order. \n", + "\n", + "Remember when we said that the boundaries drive the problem? One boundary that's 1st-order completely tanked our spatial convergence. Let's fix it!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2nd-order Neumann BCs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Up to this point, we have used the first-order approximation of a derivative to satisfy Neumann B.C.'s. For a boundary located at $x=0$ this reads,\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{p^{k+1}_{1,j} - p^{k+1}_{0,j}}{\\Delta x} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "which, solving for $p^{k+1}_{0,j}$ gives us\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p^{k+1}_{0,j} = p^{k+1}_{1,j}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Using that Neumann condition will limit us to 1st-order convergence. Instead, we can start with a 2nd-order approximation (the central-difference approximation):\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{p^{k+1}_{1,j} - p^{k+1}_{-1,j}}{2 \\Delta x} = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "That seems problematic, since there is no grid point $p^{k}_{-1,j}$. But no matter … let's carry on. According to the 2nd-order approximation,\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p^{k+1}_{-1,j} = p^{k+1}_{1,j}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Recall the finite-difference Jacobi equation with $i=0$:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p^{k+1}_{0,j} = \\frac{1}{4} \\left(p^{k}_{0,j-1} + p^k_{0,j+1} + p^{k}_{-1,j} + p^k_{1,j} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Notice that the equation relies on the troublesome (nonexistent) point $p^k_{-1,j}$, but according to the equality just above, we have a value we can substitute, namely $p^k_{1,j}$. Ah! We've completed the 2nd-order Neumann condition:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p^{k+1}_{0,j} = \\frac{1}{4} \\left(p^{k}_{0,j-1} + p^k_{0,j+1} + 2p^{k}_{1,j} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "That's a bit more complicated than the first-order version, but it's relatively straightforward to code." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Note \n", + "\n", + "Do not confuse $p^{k+1}_{-1,j}$ with `p[-1]`:\n", + "`p[-1]` is a piece of Python code used to refer to the last element of a list or array named `p`. $p^{k+1}_{-1,j}$ is a 'ghost' point that describes a position that lies outside the actual domain." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Convergence, Take 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can copy the previous Jacobi function and replace only the line implementing the Neumann boundary condition. \n", + "\n", + "##### Careful!\n", + "Remember that our problem has the Neumann boundary located at $x = L$ and not $x = 0$ as we assumed in the derivation above." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def laplace_2d_jacobi_neumann(p0, maxiter=20000, rtol=1e-6):\n", + " \"\"\"\n", + " Solves the 2D Laplace equation using Jacobi relaxation method.\n", + "\n", + " The function assumes Dirichlet condition with value zero\n", + " at all boundaries except at the right boundary where it uses\n", + " a zero-gradient second-order Neumann condition.\n", + " The exit criterion of the solver is based on the relative L2-norm\n", + " of the solution difference between two consecutive iterations.\n", + "\n", + " Parameters\n", + " ----------\n", + " p0 : numpy.ndarray\n", + " The initial solution as a 2D array of floats.\n", + " maxiter : integer, optional\n", + " Maximum number of iterations to perform;\n", + " default: 20000.\n", + " rtol : float, optional\n", + " Relative tolerance for convergence;\n", + " default: 1e-6.\n", + "\n", + " Returns\n", + " -------\n", + " p : numpy.ndarray\n", + " The solution after relaxation as a 2D array of floats.\n", + " ite : integer\n", + " The number of iterations performed.\n", + " diff : float\n", + " The final relative L2-norm of the difference.\n", + " \"\"\"\n", + " p = p0.copy()\n", + " diff = rtol + 1.0 # intial difference\n", + " ite = 0 # iteration index\n", + " while diff > rtol and ite < maxiter:\n", + " pn = p.copy()\n", + " # Update the solution at interior points.\n", + " p[1:-1, 1:-1] = 0.25 * (p[1:-1, :-2] + p[1:-1, 2:] +\n", + " p[:-2, 1:-1] + p[2:, 1:-1])\n", + " # Apply 2nd-order Neumann condition (zero-gradient)\n", + " # at the right boundary.\n", + " p[1:-1, -1] = 0.25 * (2.0 * pn[1:-1, -2] +\n", + " pn[2:, -1] + pn[:-2, -1])\n", + " # Compute the residual as the L2-norm of the difference.\n", + " diff = l2_norm(p, pn)\n", + " ite += 1\n", + " return p, ite, diff" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, this is the exact same code as before, but now we're running the Jacobi solver with a 2nd-order Neumann boundary condition. Let's do a grid-refinement analysis, and plot the error versus the grid spacing." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# List of the grid sizes to investigate.\n", + "nx_values = [11, 21, 41, 81]\n", + "\n", + "# Create an empty list to record the error on each grid.\n", + "errors = []\n", + "\n", + "# Compute the solution and error for each grid size.\n", + "for nx in nx_values:\n", + " ny = nx # same number of points in all directions.\n", + " # Create the gridline locations.\n", + " x = numpy.linspace(0.0, Lx, num=nx)\n", + " y = numpy.linspace(0.0, Ly, num=ny)\n", + " # Set the initial conditions.\n", + " p0 = numpy.zeros((ny, nx))\n", + " p0[-1, :] = numpy.sin(1.5 * numpy.pi * x / Lx)\n", + " # Relax the solution.\n", + " # We do not return the number of iterations or\n", + " # the final relative L2-norm of the difference.\n", + " p, _, _ = laplace_2d_jacobi_neumann(p0, rtol=1e-8)\n", + " # Compute the analytical solution.\n", + " p_exact = laplace_solution(x, y, Lx, Ly)\n", + " # Compute and record the relative L2-norm of the error.\n", + " errors.append(l2_norm(p, p_exact))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the error versus the grid-spacing size.\n", + "pyplot.figure(figsize=(6.0, 6.0))\n", + "pyplot.xlabel(r'$\\Delta x$')\n", + "pyplot.ylabel('Relative $L_2$-norm\\nof the error')\n", + "pyplot.grid()\n", + "dx_values = Lx / (numpy.array(nx_values) - 1)\n", + "pyplot.loglog(dx_values, errors,\n", + " color='black', linestyle='--', linewidth=2, marker='o')\n", + "pyplot.axis('equal');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nice! That's much better. It might not be *exactly* 2nd-order, but it's awfully close. (What is [\"close enough\"](http://ianhawke.github.io/blog/close-enough.html) in regards to observed convergence rates is a thorny question.)\n", + "\n", + "Now, notice from this plot that the error on the finest grid is around $0.0002$. Given this, perhaps we didn't need to continue iterating until a target difference between two solutions of $10^{-8}$. The spatial accuracy of the finite difference approximation is much worse than that! But we didn't know it ahead of time, did we? That's the \"catch 22\" of iterative solution of systems arising from discretization of PDEs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Final word" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Jacobi method is the simplest relaxation scheme to explain and to apply. It is also the *worst* iterative solver! In practice, it is seldom used on its own as a solver, although it is useful as a smoother with multi-grid methods. As we will see in the [third lesson](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_03_Iterate.This.ipynb) of this module, there are much better iterative methods! But first, let's play with [Poisson's equation](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_02_2D.Poisson.Equation.ipynb)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "###### The cell below loads the style of the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MAE6286)", + "language": "python", + "name": "py36-mae6286" + }, + "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.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/05_relax/05_02_2D.Poisson.Equation.ipynb b/2-finite-difference-method/lessons/05_relax/05_02_2D.Poisson.Equation.ipynb new file mode 100644 index 0000000..27ee709 --- /dev/null +++ b/2-finite-difference-method/lessons/05_relax/05_02_2D.Poisson.Equation.ipynb @@ -0,0 +1,847 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license © 2014 L.A. Barba, C.D. Cooper, G.F. Forsyth. Based on [CFD Python](https://github.com/barbagroup/CFDPython), © 2013 L.A. Barba, also under CC-BY license." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Relax and hold steady" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome to the second notebook of *\"Relax and hold steady: elliptic problems\"*, **Module 5** of the course [**\"Practical Numerical Methods with Python\"**](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about). Are you relaxed yet?\n", + "\n", + "In the [previous notebook](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb), you learned to use Jacobi iterations to solve Laplace's equation. The iterations *relax* the solution from an initial guess to the final, steady-state solution. You also saw again that the way we treat boundary conditions can influence our solution. Using a first-order approximation of the Neumann boundary messed up our spatial convergence in the whole domain! (We expected second-order spatial convergence from the central difference scheme, but we got closer to first order.) This was easily fixed by using a second-order scheme for the Neumann boundary. *It's always good to check that you get the expected order of convergence.*\n", + "\n", + "A word of warning: in this course module, we will introduce a different use of the word *\"convergence\"*. Before, we used it to refer to the decay of the truncation errors (in space and time) with a decrease in the grid spacing ($\\Delta x$ and $\\Delta t$). Now, we also have a relaxation scheme, and we use the word convergence to mean that the iterative solution approaches the exact solution of the linear system. Sometimes, this is called *algebraic convergence*. We'll concern ourselves with this in the next lesson. But first, let's play with Poisson." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Poisson equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The **Poisson equation** has a forcing function that drives the solution to its steady state. Unlike the Laplace equation, Poisson's equation involves imposed values inside the field (a.k.a., sources): \n", + "\n", + "$$\n", + "\\frac{\\partial ^2 p}{\\partial x^2} + \\frac{\\partial ^2 p}{\\partial y^2} = b\n", + "$$\n", + "\n", + "In discretized form, this looks almost the same as [the Laplace Equation](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb), except for the source term on the right-hand side:\n", + "\n", + "$$\n", + "\\frac{p_{i+1,j}^{k}-2p_{i,j}^{k}+p_{i-1,j}^{k}}{\\Delta x^2}+\\frac{p_{i,j+1}^{k}-2 p_{i,j}^{k}+p_{i,j-1}^{k}}{\\Delta y^2}=b_{i,j}^{k}\n", + "$$\n", + "\n", + "As before, we rearrange this to obtain an equation for $p$ at point $i,j$, based on its neighbors: \n", + "\n", + "$$\n", + "p_{i,j}^{k+1}=\\frac{(p_{i+1,j}^{k}+p_{i-1,j}^{k})\\Delta y^2+(p_{i,j+1}^{k}+p_{i,j-1}^{k})\\Delta x^2-b_{i,j}^{k}\\Delta x^2\\Delta y^2}{2(\\Delta x^2+\\Delta y^2)}\n", + "$$\n", + "\n", + "It's slightly more complicated than the Laplace equation, but nothing we can't handle. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### An example problem" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's consider the following Poisson equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla^2 p = -2\\left(\\frac{\\pi}{2}\\right)^2\\sin\\left( \\frac{\\pi x}{L_x} \\right) \\cos\\left(\\frac{\\pi y}{L_y}\\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "in the domain \n", + "\n", + "$$\n", + "\\left\\lbrace \\begin{align*}\n", + "0 &\\leq x\\leq 1 \\\\\n", + "-0.5 &\\leq y \\leq 0.5 \n", + "\\end{align*} \\right.\n", + "$$\n", + "\n", + "where $L_x = L_y = 1$ and with Dirichlet boundary conditions \n", + "\n", + "$$p=0 \\text{ at } \\left\\lbrace \n", + "\\begin{align*}\n", + "x&=0\\\\\n", + "y&=0\\\\\n", + "y&=-0.5\\\\\n", + "y&=0.5\n", + "\\end{align*} \\right.$$\n", + "\n", + "To solve this equation, we assume an initial state of $p=0$ everywhere, apply the boundary conditions and then iteratively relax the system until we converge on a solution." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To start, let's import the libraries and set up our spatial mesh." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "nx = 41 # number of points in the x direction\n", + "ny = 41 # number of points in the y direction\n", + "xmin, xmax = 0.0, 1.0 # domain limits in the x direction\n", + "ymin, ymax = -0.5, 0.5 # domain limits in the y direction\n", + "Lx = (xmax - xmin) # domain length in the x direction\n", + "Ly = (ymax - ymin) # domain length in the y direction\n", + "dx = Lx / (nx - 1) # grid spacing in the x direction\n", + "dy = Ly / (ny - 1) # grid spacing in the y direction\n", + "\n", + "# Create the gridline locations.\n", + "x = numpy.linspace(xmin, xmax, num=nx)\n", + "y = numpy.linspace(ymin, ymax, num=ny)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def poisson_source(x, y, Lx, Ly):\n", + " \"\"\"\n", + " Computes and returns the source term (right-hand side)\n", + " of the Poisson equation.\n", + " \n", + " Parameters\n", + " ----------\n", + " x : numpy.ndarray\n", + " The gridline locations in the x direction\n", + " as a 1D array of floats.\n", + " y : numpy.ndarray\n", + " The gridline locations in the y direction\n", + " as a 1D array of floats.\n", + " Lx : float\n", + " Domain length in the x direction.\n", + " Ly : float\n", + " Domain length in the y direction.\n", + " \n", + " Returns\n", + " -------\n", + " b : numpy.ndarray of floats\n", + " The forcing function as a 2D array.\n", + " \"\"\"\n", + " X, Y = numpy.meshgrid(x, y)\n", + " b = (-2.0 * numpy.pi / Lx * numpy.pi / Ly *\n", + " numpy.sin(numpy.pi * X / Lx) *\n", + " numpy.cos(numpy.pi * Y / Ly))\n", + " return b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Jacobi iterations need an exit condition, based on some norm of the difference between two consecutive iterations. We can use the same relative L2-norm that we wrote for the Laplace exit condition, so we saved the function into a helper Python file (`helper.py`) for easy importing." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from helper import l2_norm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, what value to choose for the exit condition? We saw in the previous notebook that with an exit tolerance of $10^{-8}$, we could converge well for the different grids we tried, and observe second-order spatial convergence (with the second-order Neumann BC). We speculated in the end that we might be able to use a less stringent exit tolerance, since the spatial error was a lot larger (around $0.0002$ for the finer grid). Here, we'll try with $2\\times 10^{-7}$. Go ahead and try with different values and see what you get!\n", + "\n", + "It's time to write the function to solve the Poisson equation. Notice that all of the boundaries in this problem are Dirichlet boundaries, so no BC updates required!\n", + "\n", + "There's also one extra piece we're adding in here. To later examine the convergence of the iterative process, we will save the L2-norm of the difference between successive solutions. A plot of this quantity with respect to the iteration number will be an indication of how fast the relaxation scheme is converging." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def poisson_2d_jacobi(p0, b, dx, dy, maxiter=20000, rtol=1e-6):\n", + " \"\"\"\n", + " Solves the 2D Poisson equation for a given forcing term\n", + " using Jacobi relaxation method.\n", + "\n", + " The function assumes Dirichlet boundary conditions with value zero.\n", + " The exit criterion of the solver is based on the relative L2-norm\n", + " of the solution difference between two consecutive iterations.\n", + "\n", + " Parameters\n", + " ----------\n", + " p0 : numpy.ndarray\n", + " The initial solution as a 2D array of floats.\n", + " b : numpy.ndarray\n", + " The forcing term as a 2D array of floats.\n", + " dx : float\n", + " Grid spacing in the x direction.\n", + " dy : float\n", + " Grid spacing in the y direction.\n", + " maxiter : integer, optional\n", + " Maximum number of iterations to perform;\n", + " default: 20000.\n", + " rtol : float, optional\n", + " Relative tolerance for convergence;\n", + " default: 1e-6.\n", + "\n", + " Returns\n", + " -------\n", + " p : numpy.ndarray\n", + " The solution after relaxation as a 2D array of floats.\n", + " ite : integer\n", + " The number of iterations performed.\n", + " conv : list\n", + " The convergence history as a list of floats.\n", + " \"\"\"\n", + " p = p0.copy()\n", + " conv = [] # convergence history\n", + " diff = rtol + 1.0 # initial difference\n", + " ite = 0 # iteration index\n", + " while diff > rtol and ite < maxiter:\n", + " pn = p.copy()\n", + " p[1:-1, 1:-1] = (((pn[1:-1, :-2] + pn[1:-1, 2:]) * dy**2 +\n", + " (pn[:-2, 1:-1] + pn[2:, 1:-1]) * dx**2 -\n", + " b[1:-1, 1:-1] * dx**2 * dy**2) /\n", + " (2.0 * (dx**2 + dy**2)))\n", + " # Dirichlet boundary conditions at automatically enforced.\n", + " # Compute and record the relative L2-norm of the difference.\n", + " diff = l2_norm(p, pn)\n", + " conv.append(diff)\n", + " ite += 1\n", + " return p, ite, conv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use the `plot_3d` function we wrote in the previous notebook to explore the field $p$, before and after the relaxation. We saved this plotting function into the helper Python file, so we can re-use it here." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from helper import plot_3d" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we initialize all of the problem variables and plot!" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set the initial conditions.\n", + "p0 = numpy.zeros((ny, nx))\n", + "\n", + "# Compute the source term.\n", + "b = poisson_source(x, y, Lx, Ly)\n", + "\n", + "# Plot the initial scalar field.\n", + "plot_3d(x, y, p0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That looks suitably boring. Zeros everywhere and boundaries held at zero. If this were a Laplace problem we would already be done!\n", + "\n", + "But the Poisson problem has a source term that will evolve this zero initial guess to something different. Let's run our relaxation scheme and see what effect the forcing function has on `p`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jacobi relaxation: 3125 iterations to reach a relative difference of 1.9958631078740742e-07\n" + ] + } + ], + "source": [ + "# Compute the solution using Jacobi relaxation method.\n", + "p, ites, conv = poisson_2d_jacobi(p0, b, dx, dy, rtol=2e-7)\n", + "print('Jacobi relaxation: {} iterations '.format(ites) +\n", + " 'to reach a relative difference of {}'.format(conv[-1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It took 3,125 iterations to converge to the exit criterion (that's quite a lot, don't you think? Let's now take a look at a plot of the final field:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the solution.\n", + "plot_3d(x, y, p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Something has definitely happened. That looks good, but what about the error? This problem has the following analytical solution:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p(x,y) = \\sin{\\left(\\frac{x\\pi}{L_x} \\right)}\\cos{\\left(\\frac{y\\pi}{L_y} \\right)}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Time to compare the calculated solution to the analytical one. Let's do that." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def poisson_solution(x, y, Lx, Ly):\n", + " \"\"\"\n", + " Computes and returns the analytical solution of the Poisson equation\n", + " on a given two-dimensional Cartesian grid.\n", + "\n", + " Parameters\n", + " ----------\n", + " x : numpy.ndarray\n", + " The gridline locations in the x direction\n", + " as a 1D array of floats.\n", + " y : numpy.ndarray\n", + " The gridline locations in the y direction\n", + " as a 1D array of floats.\n", + " Lx : float\n", + " Length of the domain in the x direction.\n", + " Ly : float\n", + " Length of the domain in the y direction.\n", + "\n", + " Returns\n", + " -------\n", + " p : numpy.ndarray\n", + " The analytical solution as a 2D array of floats.\n", + " \"\"\"\n", + " X, Y = numpy.meshgrid(x, y)\n", + " p = numpy.sin(numpy.pi * X / Lx) * numpy.cos(numpy.pi * Y / Ly)\n", + " return p" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute the analytical solution.\n", + "p_exact = poisson_solution(x, y, Lx, Ly)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.00044962635351970283" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Compute the relative L2-norm of the error.\n", + "l2_norm(p, p_exact)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That seems small enough. Of course, each application problem can have different accuracy requirements." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Algebraic convergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remember that we saved the L2-norm of the difference between two consecutive iterations. The purpose of that was to look at how the relaxation scheme *converges*, in algebraic sense: with consecutive solutions getting closer and closer to each other. Let's use a line plot for this." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAEYCAYAAAAUMCHfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xd8XXd9//HXR9uy9rA8ZFuS5T0TO54ZdhaBBGiSFlpCCJQQZlv6Kys0LYVCgYRCoWUkrACBhAAJCQlkxxmOR7wdb1uy5SXbGrYsb0uf3x/nSpEVybr3alyN9/PxuA/5nnPuOd/7RTbvfM/3fL7m7oiIiIhIz4qLdQNEREREBiKFMBEREZEYUAgTERERiQGFMBEREZEYUAgTERERiQGFMBEREZEYUAgTERERiQGFMBEREZEYUAgTERERiYGEWDdAICsry0tLS2PdjD7r+PHjDB48ONbN6LPUf52nPuwc9V/nqP86r6v7cNWqVVXunt/RcQphvUBBQQErV66MdTP6rMWLF7Nw4cJYN6PPUv91nvqwc9R/naP+67yu7kMz2x3OcbodKSIiIhIDCmFdyMxGmdkfzexHZvaEmU2JdZtERESkd1IIA8xsmJk9ZWbeyVP9EHjQ3T8GfBX4dedbJyIiIv3RgA9hZnYjsBQY08FxQ8zs12a2NfT6vZkVttifC7wdeBLA3ZcBw81sRjc2X0RERPqoAR/CgC8A1wBL2jvAzJKAZ4EkYDIwCTgOvGhmaaHDRgMn3L2+xUcPAcXd0WgRERHp2xTCYIG7b+/gmNuAacDn3f2cuzcAnwdKgI+HjrFubKOIiIj0MwM+hLn7uTAOuxmocPeyFp+rBDaF9gHsAlJbjIwBDAHKu6ipIiIi0o8M+BAWpmm0HabKgakA7l4NPAVcD2Bmc4ED7r62o5MfP9vZ5wFERESkrzF3BQAAM7sfuM3d33Jb0czOAE+7+ztbbX8AuAVIdfeTZjYa+B5wABgJ3Onu69u53h3AHQBJQ0tnPv3gj7vy6wwo9fX1pKWldXygtEn913nqw85R/3WO+q/zuroPFy1atMrdZ3V0nCrmd855gc3ddwPvDueD7n4fcB9A8rCxrmrH0VO16M5R/3We+rBz1H+do/7rvFj1oW5HhqcKSG9jezrBE5Ene7g9IiIi0scphIVnPVDUxvZiYEPPNkVERET6A4Ww8DwCjDazoqYNZlYATAT+EKM2iYiISB+mEBae+wlGvL5pZglmFgd8g+DpyB/GsmEiIiLSNw34EGZm95jZWuBdofdrQ6+kpmPc/QxBVf0Ggtpgm4EM4MpWFfJFREREwjLgn45098+GedxB4H3d3BwREREZIAb8SFhv0dCoem0iIiIDiUJYL3G2oTHWTRAREZEepBDWSyiEiYiIDCwKYb3E2QbdjhQRERlIFMJ6CY2EiYiIDCwKYb3EmXMKYSIiIgOJQlgvcVohTEREZEBRCOsljp8+F+smiIiISA9SCOsl6hXCREREBhSFsF5CIUxERGRgUQjrJepPKYSJiIgMJAphvYRGwkRERAYWhbBeQiFMRERkYFEI6yWO6XakiIjIgKIQ1kvUnz4b6yaIiIhID1II6yWOntRImIiIyECiENZLHKo7FesmiIiISA9SCOslDh87HesmiIiISA9SCOslFMJEREQGFoWwXuLY6XOcPNMQ62aIiIhID1EI60UOHdO8MBERkYFCIawXOVinW5IiIiIDhUJYL7K39kSsmyAiIiI9RCGsFymvOh7rJoiIiEgPUQjrRRTCREREBo5uCWFm9qsoPzfIzC43s3eF3ud2bct6p3gLfu6qVggTEREZKBKi/aCZlQJXAEOB+Fa7r4rifHcBnwMGA5XA48APzSwJ+Dt3PxltW3u7xFAU3nnoOA2NTnycxbZBIiIi0u2iCmFm9gngf4H20oJHeL7/B/wj8H1gI3BnaNetwDeB/wQ+E01b+4I4M0ZkDWLfkZPsPFzPuIL0WDdJREREulm0tyM/B3wSyHf3uNYvYH2E57sduMzd73T3B4DTAO5+miB8XRllO/uEeINphZkAbNh7NMatERERkZ4QbQg77O4/cvfqdvbfGukJ3X1rO9vPAUmRnq8vyR1kTBkRCmH7FMJEREQGgmhD2KNmNvUC+z8a4fkSzGxcWzvMbCyQGOH5+pzphVkArNpdG+OWiIiISE+Iak6Yu/+XmX3TzMYAO4DWVUZvBv4hglPeDywxsx8ArwGDzGwBMAP4LPB/0bSzL7l4dBZJ8XG8sf8oR06cISu1Xw/+iYiIDHidmZj/2QscEtHEfODrQCFwV9MlgJdDf/6+u38rwvP1OalJCVw8OotlZTUs3VnN26cOi3WTREREpBtFezvyiwS3HPO6YmK+Bz4BTAA+Afxb6Oc4d//HKNvY5ywYkwfAy9urYtwSERER6W7RhrBD7v5jd69pZ3/EE/MB3H27u9/r7l8L/dwZZfv6pIXjhwDw7KaDNDRGOpgoIiIifUm0IezZrpyYb2YLzOwRM3uo1fZfm9nfR9XCPmjKiAxG56ZSVX+a5WXtPXgqIiIi/UG0FfNPA380szV0zcT8TwA5wNdabf858DUzS3L3H0XZ1j7DzLhh2jC+/+JO/rT+APNL82LdJBEREekm0Yawpgn0xe3sj/Re2lRgvrvXn3cS9+fMbBXwHNDvQxjAu6aP4Psv7uSJdfu56/qJDE6OemUpERER6cWivR25rq0J+Z2omG+tA1gTd6+lnxdrbWn80HRmjc7m2OlzPLJ6b6ybIyIiIt0k2hA2zcz+YGaF7eyP5FYkQGJoQfC3CG0fMCEM4Lb5RQD8Yulu3DVBX0REpD+KNoSdAX4FHGxrp7u/GuH5fgq8ZGZ3mtk1ZjbTzK42sy8Ai4EfR9nOPum6KUMZmpHCjkP1PPVGZaybIyIiIt2gM7cj/+juZ9vaaWYjIjmZu98DPAJ8FXgKWAE8TTBR/5GBUKy1pcT4OD65aAwA//3sNpWrEBER6YeiDWEvmNnlF9j/p0hP6O7/AIwneFLy3xmAxVpbeu8loyjMHsSOQ/U8umZfrJsjIiIiXSzaR+/OAQ+Y2VpgC9B6Uv3QaE7q7jsISl6cx8zmuvuyaM7ZVyUlxPHPV4/jX363jm/8ZTPXTCwgM7Xfr2MuIiIyYHS2REUhcEMb+7v6/tkPgIu7+JxdysxygHsIaqY1AkXAZ9x9e7TnvOniEfz29T2s2FXDN57awtdvulB9XBEREelLekWJCjMbbmYPmNleMztrZg0tX8D0KNuJmQ0zs6fMrLsnVo0CTrn7P7j7PwHPAj/pzAnNjK/dOIXEeOPBFRW8sv1wlzRUREREYi/aEPbvHeyPtETF/cAs4FHgv4CvtHj9J+08hdkRM7sRWAqM6eC4IaElkraGXr+/QPmNNrn7Wnf/ZItN5cCwyFt9vrEF6fzjlWMB+OffruPwsdOdPaWIiIj0AlHdjnT3C068j6JExURgvLu3Xv4IADPLjvB8Tb4AXAP8K9BeHbIkglGrbcBkglupPwNeNLOL2isiG4Z30kVV/j+xqJQlO6tYVlbDP/92Lfd/6BIS4qPNzyIiItIbRP3/5GY2yMw+bWZPmtny0M9/MrNBUZxuW3sBLOQ/omzmgjDmZN0GTAM+7+7n3L0B+DxQAny86SAzWxq6XdrW67xRMzO7HsgE/ifKdp8nPs74n/deRO7gJF7dUcVXntjUFacVERGRGIoqhJlZPrAS+DawiGCC/iLgO8DrZhbpytP3mNl/mFlWO/ufj6ad7n4ujMNuBircvazF5yqBTaF9TdvmuXthO6/m9YVCAezdwK3u3hhNu9syNDOFe2+dSVJ8HL9cupufvVreVacWERGRGIh2JOybQAUw3d1T3X2Eu6cSTKDfHdofiR8C/wRUmVmlmZW1fAGTomxnOKYRzN9qrZxgYfGwmdnfENz+/Ki7nzOz73ZB+5rNKsrh7r+eBsBXntjEw6/v6crTi4iISA+yaNYmNLNygjlcZ9rYlwJscfeiCM5XDTze3m7gBnePdHSt5fnvB25zd2tj3xngaXd/Z6vtDwC3AKnufjKMa0wDVgNVLTZnunubt2fN7A7gDoD8/PyZDz/8cJjfBp4qP8tDW89gwO1Tk1gwYmDXD6uvryctLS3Wzeiz1H+dpz7sHPVf56j/Oq+r+3DRokWr3H1WR8dFWyfsTFsBDMDdT5lZpI/wVbj7h9rbaWYvRHi+rvCWwHYh7r6eCPrT3e8D7gMYP368L1y4MOxrLVwIoxbv4O6ntvKTN84wqmQst84riqS5/crixYuJpP/kfOq/zlMfdo76r3PUf50Xqz6M9nbkUTNrq0grZvYuoC6Sk7n7RR3svzKS80WoCkhvY3s6cCKcUbBY+MTCUj533Xjc4d8e28i3nt5KNKOaIiIiEhvRjoR9FXjUzJ4nmKBfC+QAlxBM0L8pmpOa2WjgCiDd3b9vZhMJbm12Z7pYD0xoY3sxsKEbr9tpn1hYSt7gZO58dAP/9+IO9tae4Os3TWNQUnysmyYiIiIdiGokzN0fB95PUN/riwTL9dxJsAD3LR3VEWvNzBLM7CfAToLCrf8a2vUZYGUUT1tG4hFgtJkVtWhPAcF3+0M3XrdLvOeSkfz4AzNJTYrnj2v3c/MPX2NPzYWqfYiIiEhvEHWdMHf/rbuPJggrlwET3X20u4c/w/xNXwYuBz4Z+lkVusaHgYeAr0fbzjDcTzDi9c1QGIwDvkHwdOQPu/G6XebKCQU8+okFFOWmsulAHTf876s8tymqRQZERESkh3S67Lq7b3X3Je6+tWmbmT0T4WneA1zm7veGqu031/dy93uAmdG0zczuMbO1wLtC79eGXkktzn+GoKxEA0FtsM1ABnBlJ6rl97jxQ9N57FOXctWEIRw9eZbbf7mSLz66gRNnwimVJiIiIj0t2jlhmNnVwEKgAGg9CeniCE93zt0vNHSTGuH5AHD3z4Z53EHgfdFcozfJHJTIjz8wi58tKefup7bym+UVLN1ZzX+/ZzoXj4p25ScRERHpDlGFMDP7KsFcsHqCSfmtK8NHWmyj0czmufvSNq41G2izHIa8VVyccftlJSwozePTD61l68Fj3PzD17h17mg++7bxpKcM7JpiIiIivUW0tyNvA97m7hmheWDFLV8Et/Qi8V3gBTP7hZl9FMg0s1vM7B7gaeC/o2zngDVxWAaPfWoBH72ihDgzfrl0N1d/+yWeeuOASlmIiIj0AtGGsIPu/uwF9i+M5GShwqVfIlir8YcE5SF+BXwM+E93/0WU7RzQUhLjufPtE/nTpy5l+sgsDtad5mMPrOYDP1vB1spjsW6eiIjIgBZtCHvOzC5UYPWrkZ7Q3e8GhgNvB24N/Rzu7t+OronSZNLwDB75+Hy+8u7JpKck8Mr2Kt7+3Zf54qMbqKqPdHEDERER6QpRL1sE/MHM1gDbgdaFqW4G/iHck5nZ6qbPufvTUbZJLiA+zvjAvCJumDac7z63jQeWV/Cb5RU8vnY/d1xewocWFGm+mIiISA+KNoTdFfpZ1M7+SCcdlQJXuHt5lO2RMOUMTuLL757CrfNG819/3sILWw7x7We38bMl5dxxeQm3zSticHLUD82KiIhImKK9HbnO3ePaexEsBRSJDe6+pr2dZnZJlO2UdpQOSednH7yEBz8yl0uKsjly4ix3P7WVy+9+kR+/XKb6YiIiIt0s2hD27x3sD/tWZMgfzOxCdbrujfB8EqZ5Y3J5+KPz+NWHZzNjZBbVx8/wtT9vZv43XuDbz26j5riqg4iIiHSHqO47dbQ2ZKjqfSSmAp8xszsJylu0rlQ/KsLzSQTMjMvG5nNpaR6Ltx7mu89vZ+2eI3zv+e3c9/JO3jtrJLdfVsLInKhq5oqIiEgbumTyj5nd5+53dOIU7wP2ExR5bevWY6TFXyUKZsaiCUNYOD6fFeU13PtyGS9sOcQvlu7mgeUVXDdlKB+cX8Ss0dmYWaybKyIi0qd11QzsWZ38/CZ3b7fkRegpTOkhZsacklzmlOSypbKO+14q4/F1+3ly/QGeXH+AScMyuG3+aN49YwQpia1XrBIREZFwdHoB7y5yewf7b+6RVshbTBiawbffO4OXP7eITy4aQ87gJDYdqOPzf9jA3K8/z9f/vJk9Na0rlIiIiEhHuiqEderelLuvaj6R2aimQrBmlhDaX9a55klnDc8axGffNoHXvnAl337PdKYXZnLkxFnufbmMy+95kVt/upwn1u/n9LmGWDdVRESkT+iq25EdjWR1yMzeD3yZoPZYJTACeMDMKoF/di142CukJMZz08WF3HRxIWv3HOEXr+3iyQ0HeGV7Fa9sryI7NZGbLi7kvZeMZFxBeqybKyIi0mt1yUhYy5GsaIQC2I+BFQRrSDYtbPgvBEsZ/WunGijdYsbILL7z3hms+OJVfPldk5kwNJ3aE2f56avlXPudl7nxB0t4aEUFx06djXVTRUREep1Oj4SZWTHwE4JFt/8IfNHdT4X2rXD32WGc5jPA1e6+JPS5mwDcfZ+ZfQh4mSjWo5SekZWaxG3zi/jAvNFs2HeUh17fw+Nr97Om4ghrKo7wpcc3cvWkAm66aASXj8snMb63TEUUERGJna64HfkD4BFgGUGR1ufN7Dp3PwaEuxhhclMAa83djzfNDZPezcyYVpjFtMIs7rp+In/eUMnvVu5heXlN85OVOYOTuGHaMG68aAQzRmap1IWIiAxYXRFuCtz9+6E/fzBUcPV5M7uG8NeQTDazAnc/2HqHmRUAmlzUx6QmJfDXMwv565mF7DtyksfW7uPR1fvYfqieXy7dzS+X7qYoN5W/umgE754xguK8wbFusoiISI/qihCW3PKNu3/dzM4CzxN+eHoEeMXMvg68BsSb2QhgBvAV4KEuaKfEyIisQXxiYSkfv2IMG/fX8cc1+3hs3X52VZ/gf57bzv88t51JwzK4ftowrp86jCIFMhERGQC6IoRtM7Nr3P3Zpg3u/i0zawS+FeY57gImAj8lGD0zoCK07wmCyfrSx5kZU0ZkMmVEJne+YyKv7azi0TX7eHbjQTYdqGPTgTrueXorU0ZkcP3U4Vw/dRijcrVUkoiI9E9dEcL+tq2N7v5tM/ttW/vM7AMEo1yfc/dzoYn815vZ1cBVQB5QBTzr7i90QRull4mPC9arvGxsPqfPNfDKtiqe3HCAZzcd5I19dbyxr45vPrWFqSMym0fItHaliIj0J50OYe5++gL79rWz64vAv7n7OQiehnT3R9z9OeC5zrZJ+pbkhHiunlTA1ZMKOHW2gZe3HebJDQd4btNBNuw7yoZ9R/nGX7YwZUQG104aytsmD2VcQZom9YuISJ/W5U8dmtl1wFc6KE1xyt1/1+L9XQTzwto750vufkVXtVF6r5TEeK6dPJRrJw/l1NkGFm8NAtnzm98cIfv2s9sYnZvK2yYP5dpJBTSqjq+IiPRB3VH6IRmY2cExcaH6X0uAU0CSmY2k/eWPcruwfdJHpCTGc92UoVw3JQhkS3ZU8czGgzy3+SC7q09w38tl3PdyGRlJxvW167l28lDmj8klOUGLiouISO8Xq/pbXwJ+zflPVu6KTVOkL0hJjOeqiQVcNbGAhkZn1e5ant5YydMbK9lbe5IHV+zhwRV7SEtOYOH4fK6ZVMDCcUPITA23VJ2IiEjPCjuEmdlUYHPTPK7OcPdHzawUuATIJlgz8t/buzTwH529pvQf8XHG7OIcZhfncNf1E/nVn16gJnUkT288yOYDdTyx/gBPrD9AfJwxa3Q2V00cwpUTChiTP1jzyEREpNeIZCRsHXDGzDYBa1u+3L0ukou2fjrSzBa4+y8ucPyCSM4vA4eZMSojng8sHMenrx7HnpoTPL2xkuc3H+L1XTUsLw9e//XnLYzOTeXKCUO4akIBs4tzSErQ8kkiIhI7kYSwTwLTCcLTe4APEqqIb2a7eTOUpYVxrvOejgT+cqGD3f0jEbRTBrCROancflkJt19WwtGTZ3ll+2Fe2HyIF7ceYnf1CX6+ZBc/X7KLtOQELhubx5UThrBowhDy0pI7PrmIiEgXCjuEufsPm/5swT2d8QSBrOk1D/irpsM7OJ2ejpRulzkokRumDeeGacNpaHTW7qnl+c2HeGHLIbZUHuMvb1TylzcqMYPphVlcFQpkk4ZlEBen25YiItK9opqY7+4ObAm9mpcUCq3zeDEwrYNT6OlI6VHxccbM0TnMHJ3D566bwN7aE7y45RDPbznEazurWbvnCGv3HOG/n91GXloyl4/L44px+Vw+Np/swUmxbr6IiPRDXfp0ZGgB7r/Qwe1F9HSkxFhhdiq3zivi1nlFnDhzjiU7qnlhy0EWbz3MgaOneGT1Ph5Zva95lOyKcflcMT6f6YVZxGuUTEREukBMSlTo6UjpTVKTErhmUgHXTCrA3dl+qJ6Xth7mpW2HWVFe0zxK9t3nt5OVmshlY/ODUbJxeQxJT4l180VEpI+KVZ0w3H0/8BgETz/q6UjpDcyMcQXpjCtI5yOXl3DizDmW7qzmpW2HWbz1MBU1J/jTuv38ad1+ACYPzwhGycblc/HobBLj9cSliIiEJ2YhrKUwnn783x5piEgrqUkJzUViAXZVHWfx1kO8tO0wS8uq2bi/jo376/jB4p2kJycwvzQ3tDB5HqNzB8e49SIi0pv1ihAWhvsJJvyLxFRR3mA+mFfMBxcUc+psA6/vqmFx6NbljkP1PL3xIE9vPAjAqJxULh2bx2Wlecwfk6fq/SIicp6YhTAzuwc46O7fMrOyDg4f3hNtEolESmJ8aNQrn38D9tae4OVtVby64zBLdlRTUXOC3yyv4DfLK4gzmFqYxeVj87i0NI+LRmWrWKyIyADXqRBmZpcDC4FUd/+CmV0BrHb3Y2F8/FJgd+jPmcDj7V0GuKEz7RTpCYXZqbxvzijeN2cUDY3OG/uO8uqOKl7edpjVFbWs23OEdXuO8L8v7CA1KZ65JblcWprH5ePyGJOfpiWVREQGmKhCmJmlExRXvSq0qRL4AvB24H4zu9Ldyy90Dnef1+Ltdnf/0AWutyyadorESnycMX1kFtNHZvHJRaUcP32OFeU1vLK9ile2H2b7oXpe2BIUjgUYmpES3Locm8eC0jxV8BcRGQCiHQn7BpBKELo2Ak8AhEbD1ob2vzfck7n73M7sF+ntBicnsChUkR+g8ugpXt1RxavbD/Pqjioq607x+1V7+f2qvQBMGpbBZWPzuHRsHpcU5ZCSGB/L5ouISDeINoRdB0x393oAM2ts2uHuD5nZZ7qicU3MbLW7a2K+9BtDM1P465mF/PXMQhobnS2Vx3h1x2Fe2V7FivIaNh2oY9OBOu59uYykhDhmjspmQWku80vzmDYikwSVwhAR6fOiDWFnmwJYO7Iu9GEz+1mE1xsV4fEifUZcnDFpeAaThmdwx+VjOHW2gZW7anllx2Fe3V7Fxv11LC2rZmlZNTyzjfTkBOaU5DB/THDrclyB5pOJiPRF0Yaw42Z2s7v/ofUOM3sHUNPB528B9rfalgukAUeAowRBLhM4DRyIsp0ifU5KYjyXhm5F8naoOX6GZWXVLNlRxWs7qymvOs5zmw/x3OZgPlleWhLzxuSxYEwuC0rzGJmTGuNvICIi4Yg2hH0V+L2ZvQq8BuSb2V3AdOCdwM0dfH6Tu1/U9MbMrgNuAv4jVEm/aXth6Fp/jrKdIn1ezuAk3jF1GO+YOgyA/UdOsmRHFUt3VrNkZxUH606fV8V/ZM4gFozJY35pHvPH5GqSv4hILxVVCAut/fg+4G7gstDmrwAVwC3u/mQHp7i11fsvAle4u7e6zl4z+zCwBHg4mraK9DfDswbxN7NG8jezRuLu7Dx8nNd2VjUHsz01J3moZg8Pvb4HgAlD00O3LnOZXZxDeoqKxoqI9AZR1wlz998CvzWz8UAeUOXuW8P87ButNo1sHcBaHNtgZkOjbWdPM7PPAne7uybpSLczM0qHpFE6JI0PzCuiodHZuP8oS3ZU89rOKl7fVcOWymNsqTzGz5aUEx9nTCvMDI2U5XLxqOxYfwURkQEr2jpha5puJ4aCV1jh6wKOm9m/A19397MtrpNIMEpWF2U7hwE/B97WE6HIzKYQFK8ViYkgZGUxrTCLjy8cw+lzDaypOMJrO6pYsrOatXuOsKYieP3fiztIToijNBM2sYP5Y/KYMjxDT16KiPSQaEfCJpvZCuCXwIPuXt3JdnwO+CPwaTPbSDA5PxuYRFCP7F2RntDMbgS+A5zt4LghoeNmhTZtAD7t7nsjvF4i8DXgTuAdkbZXpDskJwSV+eeW5PL/gPrT51hRXh0aKatm84E6NlbDxqeC/5ZKT07gkuIc5o8JPjNpWAZxcRrUFRHpDtGGsI0ExVg/CLwWCk6/AJ5w94ZIT+bufzazmQQBZi4wk+CJyD8DX3P3zVG08QvANcC/AqVtHWBmScCzwDZgMuDAz4AXzeyiDspwtPYfwHeJctROpCekJSdw5YQCrpxQAEB1/Wl++qdXqE0uYFlZ8ORly0r+mYMSmVOcw7wxucwbk8u4IekKZSIiXSTaEPYOdz8AfAn4kpktJAhk3zGzx4BfuPvaSE7o7huA90XZnrYscPdzHdRPug2YBtzo7ucAzOzzwD7g48A9oW1LgZHtnGNuaF+qu79gZkVd0nqRHpCblszsYQksXDgVgANHT7J0Z3XwKqtmb+1Jntl0kGc2HQSCJzXnluQwryQIZVrzUkQketE+HXmg1fvFZnaE4NbfPwH/CMR0nZWmUNWBm4EKdy9r8blKM9sU2ndPaNu8dj4PgJn9A5BtZj8C0kPbfgQ87+6/i/IriPS4YZmDuOniQm66uBCAPTUngkKxoWBWWXeKP2+o5M8bKgHIT09uDmTzSnIZnZuqUCYiEqZoJ+bf7+4fDM2nuoVgRGkqcAz4CcGtyb5gGsGtyNbKeXNx8g65++eb/hwaCXufu3+ss40TibWROamMzEnlPaFyGLuqTzSPki3dWc3hY6d5fN1+Hg/VKBuWmcK8klzmhkKZCseKiLTP2qkMceEPme0HVhKsIRkHPEcQvB5191Nd2sJOMrP7gdvaejrSzM4AT7v7O1ttf4AgXKa6+8kIrrUQ+BDKEZ/cAAAgAElEQVTwAeD7wH3uvr6dY+8A7gDIz8+f+fDDKoMWrfr6etLS0mLdjD4r2v5zdw4cdzZVN7ClJnjVt3oMJm+QMTEnnom58UzMiSM7pX8+eanfwc5R/3WO+q/zuroPFy1atMrdZ3V0XLQhrBHYTBC8HmhZ5b63iTKE/ZpgflpEISxa48eP961bO1vlY+BavHgxCxcujHUz+qyu6r/GRmfrwWPNI2XLy6qpO3X+rIDivMHMbXH7Mj+9f1Tz1+9g56j/Okf913ld3YdmFlYIi3Zi/gZ3nx7lZ3uTKkJzuFpJB070RAAT6S/i4oyJwzKYOCyDv7+0mIZGZ9P+OpaWBZX8X99VS3nVccqrjvPgigoASoekNc8pm1uSS87gpBh/CxGRnhNtCJtzoZ1m9gN3/0Q0JzazUUCuu68xs4QwJ9hHaz0woY3txQT1wkQkSvFxxtTCTKYWZnLH5WM419DIhn1Hm+eTrdxVy45D9ew4VM+vlu0GgiWWmkbJ5hTnkpmqJZZEpP8KO4SZ2QjgtLtXAe/p4AmoiIuVmtn7gS8DRUAlMAJ4wMwqgX9ub1mjTnoEuNfMitx9V6gdBcBEgpplItJFEuLjuGhUNheNyuYTC0s5c66RdXuPND95uaqitnmJpZ8v2YUZTByaESo2m6NQJiL9TiQjYWsInhqcA9zfwbERBaZQAPsxQdX8nwPvD+36F4Jq9v8KfDWSc4bpfuBTwDfN7BagEfgGwff8YTdcT0RCkhLiuKQoh0uKcvjHq8Zy6mywxFIwUlbF2j1H2HSgjk0H6vjZkvK3hLLZxTlkper2pYj0XZGEsA/xZjX4zbQ/2mXAkxG24zPA1e6+BMDMbgJw931m9iHgZSIMYWZ2D0HF/FGh903FY2e7+5nQ+c+Y2TUEQW8TQXh8A7gywmr5ItJJKYnxzZX5uWYcJ880sKailmVl1Swrq1EoE5F+J+wQ5u4tg9Xd7r679TFmNhwoAe6OsB3JTQGsjeseN7OI5665+2fDPO4gXVupX0S6wKCkeOaX5jG/NA+AU2cbWF1Ry7KyGpaVVbO2ou1QNqckh7klucxRKBORXi7aifkfoe2CrCXAA8Bf2tnfnmQzKwgFovOE5mi19QSjiAwgKYnxzB+Tx/wxHYeypjllE4ZmMFehTER6qWhD2OC2Nrr7q2Y2Boho3UiCCfKvmNnXgdeA+NCDADOArwAPRdlOEemnwgllmw/UsVmhTER6qUiejhxF8OQiwGAzu4xg/td5hwGFRD5ydRfBE4k/JZiXZUBFaN8TBAuFi4i0q61QtqbiSGhOWTVrFMpEpJeJdGL+l3jzycfFbRxjBE8Y/mckjQgtdXS9mV1NsGZjHkEh1Wfd/YVIziUiAq0m+tNxKIOgTlkw0T8IZdkqHisi3SiSEHY/QfAygnISt7dxzFlgV7TLGLn7cwTrUJ7HzEa5e0UbHxERCUuHoWzPkeY6Zfe/tgtQKBOR7hXJ05G7gd0AZvYdd3+p21r1Vn8ELu7B64lIP9dWKFu7581QtrpCoUxEuldUE/Pd/QcX2h/pckNmlgF8DlgIFADxrQ4ZHmkbRUQikZIY3xywILJQlnbiHNOOn9HalyISkWifjuzICiIbufoJcCWwFNhJMK+siQE3dF3TREQ6FkkoA/i/tc+2GCnLYXaxFiQXkQuLOoSZ2cXAhwlqgyW32l0a4ekWAJPbqhMWutbvIm+hiEjXaSuUrdtzhGVlNTy1egc767jA7UuFMhF5q6hCmJm9Hfg9sB6YAqwM7RoKjG/xPlw72gtgAO7+N9G0U0Sku6QkxjOnJJc5JblMT9jH3AWXNYeyZWXnL0jeFMrGF6Q3V/SfXZxDXlrr/34VkYEk2pGwfweucvdlZrbG3Rc17TCzvwHmRni+n5rZx4B73f0ti3+b2VJ3nxdlW0VEul3LUPZPjD1vpCy4fVnL1oPH2HrwGL9cGqz6VjokjTnFoTplJTkMSU+J8bcQkZ4UbQgb5O7LQn8+r2Cru//OzD5+oQ+bWVu1vyYCXzGzMuBEq32To2yniEhMtA5lp881sG7PUZaVVbO8vJpVu2vZcaieHYfq+fXyoAJPSd7gFmtf5jI0U6FMpD+LNoQ1tPjzOTMb5u4HAMwsC5jQwecv4a23LLe0+HPrSvwiIn1ackI8s4tzmF2cA4zlzLlGNuxrcftydy1lVccpqzrOgyv2ADA6N7XFSFkuI7IGxfZLiEiXijaE7TOzrwBfA14CnjGzn4T2fQjY1MHnd7S8hdkRM1sTXTNFRHqnpIQ4Zo7OYeboHD65qJSzDY28se8oy8uDULZyVy27q0+wu/oED6/cC0Bh9iDmFOc2L7VUmD0IM/03q0hfFW0I+zbwXiCfIIjNA74T2lcG/F0Hn39HOBcxsySCUTfNBxORfi0xPo6LRmVz0ahsPnbFGM41NLLpQF1w+7KshhW7athbe5K9tXv5w+oglA3PTGmeTzanOJfRuakKZSJ9SLTFWhfTYu1IM1tAUJYiGdjSUaHWpluXLT7/P+7+6TYOfTvwIPAp4GfRtFVEpC9KiI9jWmEW0wqzuOPyMTQ0OpubQll5DSvKa9h/9BSPrNnHI2v2AVCQkdw8n2xOSQ4leYMVykR6sS4p1hp6onF703sz+4G7fyKCU1zeznkfM7PpwKMohInIABYfZ0wZkcmUEZncflkJjY3O1oPHzhspO1h3msfW7uextcHyvfnpycwOzSmbW5xD6ZA0hTKRXiSsEGZmH4jwvGHdbgzTCUCPCImItBAXZ0wclsHEYRl8aEExjY3OjsP1zaFseXk1h4+d5sn1B3hyfXDzIXdwUnMom1OSw7gh6cTFKZSJxEq4I2H3R3jet9T6as3MvkRQb6zpfcMFDn8swuuLiAwocXHGuIJ0xhWk84F5Rbg7Ow8fb759ubysmkPHTvOXNyr5yxuVAGSnJnJJ0ZuhbOLQDIUykR4UbgjbTPijWwY8GcZxi1sc/1HgR20ccxYoBx4J89oiIgKYGaVD0igdksb7547G3dlVfYLlobUvl5fXcODoKZ7ZdJBnNgULlmSkJLw5Ulacy6ThGcQrlIl0m3BD2PfcfXe4JzWz73V0jLu/RFDeAjMb5e5fDvf8IiISGTOjOG8wxXmD+dvZo3B39tScZFl5dfMtzH1HTvLc5kM8t/kQAOnJCcwqym6uUzZleAYJ8XEx/iYi/UdYIczd721ru5ldDiwEUt39C2Z2BbC6veMvcP6/j+R4ERHpHDNjVG4qo3JTec+skQDsqTnRfOtyeXkNFTUneHHrYV7cehiAwUnxzCrKaS6JMa0wk0SFMpGoRbuAdzrBLcKrQpsqgS8QlJS438wWufuuLmmhiIj0iJE5qYzMSeWvZxYCsP/ISZaXN030r6G86jgvbTvMS9uCUDYoMZ5ZRdnMKc5hTkkQypIT4mP5FUT6lGhLVHwDSCUIXRuBJwBCo2FrgW8SFHMVEZE+anjWIG68qJAbLwpC2cG6U+dN9N95+DivbK/ile1VACQnxDFzdHZznbIZI7NISVQoE2lPtCHsOmC6u9cDmFlj0w53f8jMPtMVjRMRkd6jICOFd88YwbtnjADg0LFTrCivaS6Jse1gPa/trOa1ndVAsDTTRSOzmBOqU3bRqGwGJSmUiTSJNoSdbQpg7ci60IdDdcdmAJ/rqLq+iIj0TkPSU7hh2nBumDYcgOr607y+q6Z5UfItlceCUbPyGr4HJMYb0wuzmktizBydTWpSl9QMF+mTov3tP25mN7v7H1rvMLN3ADUdfP6LwL81BTAzu8ndVYZCRKQPy01L5ropw7huyjAAjpw4w4ryIJQtL69m04E6Vu6uZeXuWv7vRUiIM6YWZjI8/gwMO8SsohzSkhXKZOCI9rf9q8DvzexV4DUg38zuAqYD7wRu7uDzp9z9dy3e38UFaoGZ2UvufkWUbRURkRjISk3i2slDuXbyUACOnjzLyl01zfPK3th3lDUVR1gDPFn+erA00/CM5pGyWUU5ZKQkxvZLiHSjaBfwftTM3gfcDVwW2vwVoAK4xd07KtYaZ2YfApYAp4AkMxtJULi1LbnRtFNERHqPzEGJXDWxgKsmFgBw7NRZVu6q5XcvrWX/ucFs2HeUdXuD170vlxFnMHl4ZvPTl7OLcshMVSiT/iPqcV93/y3wWzMbD+QBVe6+FcDM3u/uD1zg418Cfg0kt9i2K9q2iIhI35OeksiiCUOwyiQWLlxA/elzrNpd21ynbP3eI2zYd5QN+47yk1fLMYOJQzOa65TNKc4he3BSrL+GSNQ6ffM9FLy2ttr8/4B2Q1hoJK0UuATIBr5Mi3UkWzHgPzrbThER6d3SkhO4Ylw+V4zLB+DEmXOs3n2kuVbZ2j1H2HSgjk0H6vj5kl0ATBia/uZIWXEOeWnJF7iCSO8SUQgzs2RgDpADvO7u+1rtnwfcSTA37ILcfT+hhbnNbIG7/+IC110QSTtFRKTvS01K4NKxeVw6Ng+AU2cbWF1R21wSY3XFEbZUHmNL5TF+sTRYWW/skLQ3R8pKchiSnhLLryByQWGHMDMrAv4CjAttOm1m73H3J8zsKoKRrEuBQwTzw8Lm7h/pzH4REen/UhLjmT8mj/ljglB2+lwD6/YcDU30r2bV7lq2H6pn+6F6HlhWAUBJ/mDmFOcyNxTMhmYqlEnvEclI2DeBM8C/AInAR4BvmVkx8F1gNfBB4CF3PxtpQ8xsEPBR4BpCc8yAZ4D73P1kpOcTEZH+LTkhntnFOcwuzgHGcuZcIxv2HWmuU7Zqdy1lh49Tdvg4D64IQllRbmrzKNmcklxGZA2K7ZeQAS2SEHYJMNvdqwDM7FFgG3ALcLW7vxBtI8wsH1gMTCR4WrIWmEqwLNJHzGxh03VFRETakpQQx8zROcwcncMnF5VytqGRN/Ydba5TtnJXLbuqT7Cr+gS/XbkHgMLsQUFJjOIc5pbkUpg9CLP2HtQX6VqRhLBTLYOQu+8wsyrghi4ISN8kKG/xt+6+oWmjmU0lWKfym8CHO3kNEREZQBLj47hoVDYXjcrm4wvHcK6hkY3765on+q/YVcPe2pP8ftVefr9qLwDDM1OYEwplc0pyKcpNVSiTbhNJCDvdxrb9bQUwM/svd/9iBOdeBIx39zMtN7r7BjO7GdgSwblERETeIiE+jukjs5g+Mos7Lh9DQ6Oz+UBdc/HYFeU17D96ikfX7OPRNcFzZ0PSk5tD2dySHMbkpymUSZeJJIR5G9sa29gGwQLfkYSwM60DWPNF3U+ZWVsBUEREJGrxccaUEZlMGZHJ7ZeV0NjobD14rLlO2fLyGg4dO82f1u3nT+v2A5CXlvTmnLLiXMYOSSMuTqFMohNJCJthZg2ttlkb26Jx1MxucPcnWu8ws3cBdV1wDRERkXbFxRkTh2UwcVgGH1xQjLuz41A9y8prmoPZ4WOneXLDAZ7ccACA7NREZhe/WRJj4tAMhTIJWyQhrBZ4PIzjDLghwnZ8FXjUzJ4HVoaulUPwMMAi4KYIzyciItIpZsbYgnTGFqRz69zRuDvlVcdZXh5a/7Kshsq6Uzy98SBPbzwIQEZKwnmhbNKwDBLi42L8TaS3iiSEVbj7h8I50MzWRNIId3/czN5PsBbltS127SFYi/JPkZxPRESkq5kZJflplOSn8XezR+HuVNScYHlZDctCk/33HTnJc5sP8dzmQ0CwCsCsouzmUDZ1RCaJCmUSEkkIu7bjQ6I6FrjwWpQiIiK9jZkxOncwo3MH855LRgKwt/ZEc0X/5eU17K4+weKth1m89TAAqUnxzByd3VwWY1phFkkJCmUDVdghzN0Pd8exbXy2rbUoRUREer3C7FQKZ6Zy88xCACqPnmJ5eXVzrbKyw8d5ZXsVr2wPCgukJMZx8ag3R8pmjMwiJTE+ll9BelCnF/AWERGRtg3NTOHdM0bw7hkjADh07BQrWswp236ontd2VvPazmogKDg7Y2QWc0N1yi4elc2gJIWy/kohrIuYWQrwZYI+zQFK3f2y2LZKRER6kyHpKdwwbTg3TBsOQHX9aVaEymEsK6tmS+UxVoRqlvHCDhLjjWmFWc3FY2eNzmZwsv6vu7/o1/9Lmtkw4OfA29y9u58Z/jrwG3d/PXTtOd18PRER6eNy05J5+9RhvH3qMACOnDjTHMqWl1ezaX8dq3bXsmp3LT9YvLO5ttnckhzmFucyqyg7xt9AOqPfhjAzuxH4DnDBxcTNbEjouFmhTRuAT7v73giuNYigLMf60HWzgO9F024RERm4slKTuHbyUK6dPBSAulNnWbmrJvQEZg1v7DvKuj1HWLfnCPe+VEacwaj0OK6u38ScklxmF+WQmZoY428h4eq3IQz4AnAN8K9AaVsHmFkS8CzBQuSTCVYF+Bnwopld5O71YV6rKHSNeHf/YmjNy8VmNtHdazv3NUREZKDKSEnkygkFXDmhAID60+dYtbuW5WXVLCurZv3eo+yqa+Qnr5bzk1fLMYMJQzOal1maXZxLzuCkGH8LaU9/DmEL3P1cB2t83QZMA25093MAZvZ5YB/wceCe0LalwMh2zjEXSA/9+WFoXvOyErgK+H0nv4eIiAgQ1B27Ylw+V4zLB+DEmXP8/PGXOJVRyPKyGtbuOcLmA3VsPlDH/a/tAmBcQdp5Sy3lpyfH8BtIS/02hDWFqg7cTFCEtqzF5yrNbFNo3z2hbfMudBIza1pDs+VammcB/aaLiEi3SU1KYHJePAsXjgfg1NkG1lQcCeqUldWwuqKWbQfr2Xawnl8t2w1ASf7g5jplc0tyKchIieVXGND6bQgL0zSCW5GtlROMYoXF3feb2RLgCuBJM8sGioFXuqSVIiIiYUhJjGfemFzmjckF4PS5BtbvPdq89uXKXbWUHT5O2eHj/GZ5BQBFualvjpSV5DIia1Asv8KAYu4e6zZ0KzO7H7itracjzewM8LS7v7PV9geAW4BUdz8Z5nVGE4yc7QVGAz9va0HyFsffAdwBkJ+fP/Phhx8O7wvJW9TX15OWlhbrZvRZ6r/OUx92jvqvcyLpv3ONzq66RrbWNLClppHttQ2cajj/mLxBxvjseCbkxDE+J578QUYHU3v6vK7+HVy0aNEqd5/V0XEDfSSsPRH/trn7buA9ERx/H3AfwPjx433hwoWRXlJCFi9ejPoveuq/zlMfdo76r3M603/nGhrZuL+u+fblil01VJ08R9XJcyzZHxwzLDOluU7ZnOIcivMG97tQFqvfwYEewqp4c1J9S+nAiXBHwURERPqihPg4po/MYvrILO64fAwNjc7mA3VBnbKyalbsquHA0VP8ce1+/rg2SGVD0pOZHZpPNrckhzH5af0ulPWUgR7C1gMT2theTFAvTEREZMBoKgY7ZUQmH760mMZGZ9uhY28uSl5Ww6Fjp3li/QGeWH8AgLy0JGYX5zTPKxs3JJ24OIWycAz0EPYIcK+ZFbn7LgAzKwAmAnfGsmEiIiKxFhdnTBiawYShGdw2vwh3Z+fhepaVhda/LK/h8LHT/HlDJX/eUAlAVmois4vevH05cVgG8QplbRroIex+4FPAN83sFoISE98geDryhzFsl4iISK9jZpQOSad0SDrvnzsad6e86njz7cvl5cHty2c2HeSZTQcBSE9JCIWyYLRs8vAMEuLjYvxNeod+G8LM7B6CivmjQu/XhnbNdvczAO5+xsyuIVi2aBNBxfw3gCsjqJYvIiIyIJkZJflplOSn8XezR+Hu7Kk5ybLQrcvl5dXsrT3J81sO8fyWQ0BQcHbm6OzmUDatMJPEARrK+m0Ic/fPhnncQeB93dwcERGRfs/MGJWbyqjcVN4zK1hoZt+Rk8EoWSiU7ao+wUvbDvPStsMADEqMZ1ZRdvMTmNMKM0lOiI/l1+gx/TaEiYiISOyNyBrETRcXctPFhQBUHj0VTPIP3cLcefg4r2yv4pXtVQAkJ8Rx8ag3R8ouGpVFSmL/DGUKYSIiItJjhmam8O4ZI3j3jBEAHD52mhXlTRP9q9l2sJ6lZdUsLasGtpMUH8eMkVnNoezi0VmkJvWP+NI/voWIiIj0SfnpyVw/bRjXTxsGQM3xM6wor2ZZWQ3Ly2vYUlnHil1BIdn/ZQcJcca0wszmpy9nFeWQltw340zfbLWIiIj0SzmDk7huyjCumxKEsqMnzrJi15tPX27cf5TVFUdYXXGEHy7eGdQ2G54RLEpeEoSyjJTEGH+L8CiEiYiISK+VmZrINZMKuGZSAQB1p86yaldt8xOYG/YdZd3e4HXvy2XEGUwanhEUjy3OYXZxDlmpSTH+Fm1TCBMREZE+IyMlkUUThrBowhAAjp8+x6rdtc3FY9fvPcIb++p4Y18dP321HDMYX5AejJSFQlluWnKMv0VAIUxERET6rMHJCVw+Lp/Lx+UDcPJMA6sralleVs2y8hrW7jnClspjbKk8xv2v7QJg7JC05on+c0pyYtZ2hTARERHpNwYlxbOgNI8FpXkAnDrbwNo9R5rrlK2uqGX7oXq2H6rngWUVAAxNNRbVbGBuKJgNzUzpkbYqhImIiEi/lZIYz9ySXOaW5AJjOXOukfV7j7A8VBZj1e5aKk808OCKCh5cEYSy0bmpQfHY0EhZYXZqt7RNIUxEREQGjKSEOGYVBU9RfnJRKWcbGvnln17kbHYRy8qqWbmrlt3VJ9hdfYKHV+4FgoKzc0pymBsKZaNyUjHr/KLkCmEiIiIyYCXGxzEmK56FV4zhY1eM4VxDI5sO1DXfvlxRXsO+Iyd5ZPU+Hlm9D4ChGSnnzSkryRscVShTCBMREREJSYiPY1phFtMKs/jI5SU0NDpbKs8PZZV1p3hs7X4eW7sfCArOzi7OYW5xTui2Z5jX6q4vISIiItLXxccZk4dnMnl4Jn9/aTGNjc72Q/XB+pehYHb42GmeXH+AJ9cfiOjcCmEiIiIiYYqLM8YPTWf80HQ+MK8Id2fn4eMsb1pqqaya3WGeSyFMREREJEpmRumQNEqHpHHLnNG4O3F3hffZuO5tmoiIiMjAEckEfYUwERERkRhQCBMRERGJAYUwERERkRhQCBMRERGJAYUwERERkRhQCBMRERGJAYUwERERkRgwd491GwY8MzsGbI11O/qwPKAq1o3ow9R/nac+7Bz1X+eo/zqvq/twtLvnd3SQKub3DlvdfVasG9FXmdlK9V/01H+dpz7sHPVf56j/Oi9WfajbkSIiIiIxoBAmIiIiEgMKYb3DfbFuQB+n/usc9V/nqQ87R/3XOeq/zotJH2pivoiIiEgMaCRMREREJAYUwkT6MDMbZmZPmZmGtKOg/hORWFIIixEzG2JmvzazraHX782sMNbtiiUzKzKzejNb28Yrq8VxiWb2n2a2xczeMLPXzOzSds75aTPbZGbrzWy1mf1Vz32j7mVmNwJLgTEdHNfl/WVmt5jZutBxb5jZRzr/jXpWBP23q53fyavbODasfjGza81shZltCP3vcqeZ9al/j81shpn92MxWhb7zJjP7npnltzouzcz+L/Tv3CYze8bMJrdxvgH19zqC/jvTzu/fpDbOOWD+/gKY2Rgz+1aoD1eZ2TYze8XMrm91XO/9N9Dd9erhF5AErAN+R1CrLR74BbAdSIt1+2LYL0XA4jCO+xGwDcgPvb8dOAnMaHXcFwiK740Jvb8GOAu8PdbftYv6azkwFrg/+KvcM/0F/C1wGpgdej8NOA58NNZ90k39tyvM84XVL8ClwBngr0LvRwL7ga/Huk8i7L8twB+AwaH3I0LbtgGDWhz3F2AJkBp6/5/AYWBEd/6e9vZXBP0X7u/fgPr7G2r7p4C9QGnofRxwN9AAXNFdv1td2Ycx78SB+AI+AjhQ0mLb0NAvzmdj3b4Y9ksRHYQwYDzQCPx9q+0bgSdbvM8K/aX4SqvjngQ2xvq7dlF/JYR+3k87IaKr+yv0j9we4Jetjvs+UA0kx7pfurL/Qvt3hXGusPuFIJC83Oq4zxIEs+Gx7pcI+m9L0//5tdj24dC/bTeH3l8Ten9li2OSgBrg+y22Dbi/1+H0XwS/fwPu72+o3TcCt7fRFw58uzt+t7q6D/vU8Hc/cjNQ4e5lTRvcvRLYFNon7bsRMODFVttfAK41s7TQ++uA1HaOm2RmE7q1lT3A3c+FcVhX99dsoLCd43KAReG1PvbC7L9whdUvZjYMmN/OcYnAu7qwTd1tmrvvaLVtf+hndujnzQQjCa82HeDuZwiCaMt/6wbi3+tw+i9cA+7vL4C7P+ruP2m1OSP083DoZ6/+N1AhLDamAeVtbC8HpvZwW3qbAjN7wMzWhO7v/8bMWvbJNIL/qqlo9blyglu7k1oc17S99XEt9/d3Xd1fA7JfzexuM1sZ+p18xsxah6Vw+2VqmMf1eqEw1do4glGIl0PvpwH72zi2nP/f3v3HWl3XcRx/vgQ1SKSU+RNTNtbmALuEv8CZOnHWKmTVdE0zZIRsmcMiM8qJmjQrXc4faYK6/rC5NpzVSoklU2KThl5+hIIZNOYciKwhQQj47o/P58wvh3PvPdx7uN/D/b4e29055/v9fD/3c9473+99n8/n8/3cdK6fVChXqfO6yfgBDJX0qzzn6U1Jz0m6uO44n7+ApNNJPVKv5kdo82ugk7ByjADeb7B9B+mEG9LP7WkX+4F9wIPABOBc0rfoVySdl8uMAHZFxP66Y3fkxxML5eDgONeXG+haHa8qxnUr8BpwETAGeA54TtJNhTKVj5+kQcB0YGFEbMibu7vWwYFxqfR53UX8IA2RPQtcQPoDvw5YKumqQplKf/7yBP1/kuaHDSLNt6y9p7a+BjoJay8quwFliojNETEuIl6JiA/zSTSLdBGa38Phzcau0jEuaHW8BmxcI+L8iPhtROyJiL0R8TDwJ2C+pI/1cPiAjUsDt5O+RN3SRFl//g7WMH4RMSoiFkfEvojYDcwFXgd+0USdlYhfRLwVEaOB4aQJ+Ku6usOORJMAAAfUSURBVPuxoC0+g07CyrENGNZg+zBSxr67n9vTtnIs1gAX5k3bSL2Fg+qK1uL5XqFccXtX5Qa6VsfLcU1eIb3n2lILfY3f8XXljiiSbgCuJt1FtrOwq7trHRwYl8qe193E7yCRZoGvAEZLqvW6+PwF8hf3W4AtwCN5c1tfA52ElWM16U7AeqNICUclSRou6ZgGu/aTupghxe4o0m39RaNI3yJfL5SDg+M8qm7/QNfqeFUqrpKGFCbuFtWGNoqfS+g5LmuaLHfEkPQN4HukOyC31u1eDZzW4LweBWwplK/sed1d/PIaa42mp/T28zeg4pfPzwN6oHKSugYYK+lY2vwa6CSsHIuAMyWdVdsg6WTgbNK6MVX1AHV3h+aL9zjSREtIcyMCuLTu2MuAxRFRG6d/HtjVRbl1EfFGy1rd3lodrxWkeReNym0Hlragze3kGuC+BtsnkNYJWpdfNxWXiHiHtEBso3J7gT/0vcn9R9J1wA+AyfkObyR9SdLMXGQR6a7PSYVjjsmvi9e6Sp7XTcRvDjC7waETgLcLSVtVz98/89EoSdFZpDlaH9Du18Cy1/mo4g9pnZzVwDOkuzOOAp7Ei7U+RUq2Ts2vB5ESs/3AFYVyjwLrgRH59XS6XnjvXfJ6bMBkjsBFHZuMW3Szv6XxIi1U+D/g3Px6HLCTI3Cxx57iB0wjXczPK2y7hnS3Vf16Qk3FhY8Wa52SX48E3ubIW6z12vw5mgNcV/h5DJhXKPc88DIfLdZ6J10v1lqZ87qZ+AHzSHf1jS4cN4eUVNSve1W585eU8CwGTsyvBXwnx+euQrm2vQaWHsSq/gAnA0+TJhGuJ30rPKPsdpUck3HAQ6T/JrAq/2FaAlxWV+5o4Cc5bmtJPQsXd1HnbFJvxWrSHW5Ty36fLYzXz4FO0revyM87gWMOd7zyH5DV+WctMLPseByO+OXz9Hbg73nfphyXhu+32bgAV+Y6V5MW7ZwLHFV2TA4xfrW4NfqZVyg3jLRcwAbS0M9fgDEN6qvUed1M/EhDXPfm99hJWiR0OYXFXHsTl4Fw/ub3cRGpA2Ntjs8bpDXorgV0OD9brYqhcmVmZmZm1o88J8zMzMysBE7CzMzMzErgJMzMzMysBE7CzMzMzErgJMzMzMysBE7CzMzMzErgJMzMzMysBE7CzMzMzErgJMzMBhRJJ0nqlLRdUuTnM/K+2ZKmlty+qZIO+n+AksbnNp9fRrvMrP85CTOzASUitkZEB/D7/LojIhbk3bOBUpOw/Psb/VPm/wL/zo9mVgGDy26AmZlBRGwAxpfdDjPrP+4JM7MBT9IZkjqB04ApeYiyU9LkQpmZktZJWi/pLUnzJR1d2F8b4twk6UpJSyW9nYc8PyGpQ9IzhbpflfTNuna8AEwBTiuUuy3X15nrmld3zFhJf8y/d6OkxZI+W9g/K7c7JH1b0q8lrcrlb6qr6/i8f42k1yStlHSXpKEtDbiZNcU9YWY24EXEZqBD0iZgaURMK+6XdCtwN3B5RCyTdCrwEnAKMD3X0SHpKeArwBeAy4AhwL9yNZ8H9gDnRsQ+SZ8Glkt6PyIW5TquzHVcmodMi16QFHXtGg38DXgc+HJE1JK0lyRNjIg1EfGopOeBjcCNwFURsVHSTOBRSUsi4o1c5f3A6cD43MYJwDLgCWDTocbVzPrGPWFmVmmShgN3AL+LiGUAEfEOcB8wTdKoukOGAfMj2QVMBHYATwE3R8S+XMcGYAnwrT40b15+vD0iagnaPaR5Y/c0KP/XiNiYny8CBHyusP9CYHOhjSuBH+f2m1k/c0+YmVXdRGAoqcepaC0pibmE1MtU815EbK29qCU9knYAcyR9Mde3H/gU8G4f2jYZ+EdE7C78vr2SXgMmS1IhOQPYUHi+PT+eXNj2EjBL0nHAk8CLEXFfH9pnZn3gJMzMqm5EfrxV0o2F7YOBLaSer6KdXdTzBGmI8pLa8F9t6LGPbVvZYPt20lDoUA68m3JX7UlEfCgJYFBh/83AemAW8HXgXUn3Az+LiA/70E4z6wUnYWZWddvy4x0R8ZveVCBpCPA14JHC/KtW2Aac0GD7CcBuCklXM/Iw5APAA3k9srnAT/PvWdDdsWbWep4TZmZVspc0xIikMyVNApaTepM+U19Y0hOSxjRR72BSj1PUbT+lhzZ8XNKUbupdAowp3r0oaTDQASypG4rskaSFtboiYgXwVeA/wDmHUo+ZtYaTMDOrko3AyPx8JjAjInaQJubPkHQBgJLvk9bt6rFnKyLeB14GrpY0MtcxCbi8izaMkHQsMAn4ZTdV30lK7O5WHlsk9V4NA37UU7sauJx0B2XNObmuF3tRl5n1kQ7xi5SZWVuTdBKwmDQp/pPAKuChiFiQE6OFwD5S79f1+S5GJN0AfBc4ljTMtxL4YW0SvqQXSb1lxwHrgMcj4uHC7z0DeJB0B+IG4E1ST9gVufzUiNiU2/cMaamID0hJ1R7g3lz/FmBFREzJ9Y7N+8aSErI3gdvynY1IuoaURJ4NbAYeA54Fni7Utzgirpc0HZiW47I/N/3BiFjY+4ibWW85CTMzMzMrgYcjzczMzErgJMzMzMysBE7CzMzMzErgJMzMzMysBE7CzMzMzErgJMzMzMysBE7CzMzMzErgJMzMzMysBE7CzMzMzErgJMzMzMysBP8H2emV4l4VYEEAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the convergence history.\n", + "pyplot.figure(figsize=(9.0, 4.0))\n", + "pyplot.xlabel('Iterations')\n", + "pyplot.ylabel('Relative $L_2$-norm\\nof the difference')\n", + "pyplot.grid()\n", + "pyplot.semilogy(conv, color='C0', linestyle='-', linewidth=2)\n", + "pyplot.xlim(0, len(conv));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It looks like in the beginning, iterations started converging pretty fast, but they quickly adopted a slower rate. As we saw before, it took more than 3,000 iterations to get to our target difference between two consecutive solutions (in L2-norm). That is a *lot* of iterations, and we would really like to relax faster! No worries, we'll learn to do that in the next notebook." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Spatial convergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For a sanity check, let's make sure the solution is achieving the expected second-order convergence in space." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[nx = 11] Number of Jacobi iterations: 249\n", + "[nx = 21] Number of Jacobi iterations: 892\n", + "[nx = 41] Number of Jacobi iterations: 3125\n", + "[nx = 81] Number of Jacobi iterations: 10708\n" + ] + } + ], + "source": [ + "# List of the grid sizes to investigate.\n", + "nx_values = [11, 21, 41, 81]\n", + "\n", + "# Create an empty list to record the error on each grid.\n", + "errors = []\n", + "\n", + "# Compute the solution and error for each grid size.\n", + "for nx in nx_values:\n", + " ny = nx # same number of points in all directions\n", + " dx = Lx / (nx - 1) # grid spacing in the x direction\n", + " dy = Ly / (ny - 1) # grid spacing in the y direction\n", + " # Create the gridline locations.\n", + " x = numpy.linspace(xmin, xmax, num=nx)\n", + " y = numpy.linspace(ymin, ymax, num=ny)\n", + " # Set the initial conditions.\n", + " p0 = numpy.zeros((ny, nx))\n", + " # Compute the source term.\n", + " b = poisson_source(x, y, Lx, Ly)\n", + " # Relax the solution.\n", + " # We do not return number of iterations\n", + " # or the convergence history.\n", + " p, ites, _ = poisson_2d_jacobi(p0, b, dx, dy, rtol=2e-7)\n", + " print('[nx = {}] Number of Jacobi iterations: {}'.format(nx, ites))\n", + " # Compute the analytical solution.\n", + " p_exact = poisson_solution(x, y, Lx, Ly)\n", + " # Compute and record the relative L2-norm of the error.\n", + " errors.append(l2_norm(p, p_exact))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the error versus the grid-spacing size.\n", + "pyplot.figure(figsize=(6.0, 6.0))\n", + "pyplot.xlabel(r'$\\Delta x$')\n", + "pyplot.ylabel('Relative $L_2$-norm\\nof the error')\n", + "pyplot.grid()\n", + "dx_values = Lx / (numpy.array(nx_values) - 1)\n", + "pyplot.loglog(dx_values, errors,\n", + " color='black', linestyle='--', linewidth=2, marker='o')\n", + "pyplot.axis('equal');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That looks pretty much second order! Remember that the boundary conditions can adversely affect convergence, but Dirichlet boundaries are \"exact\" and will never impact your convergence." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Final word" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have used the difference between two consecutive solutions in the iterative process as a way to indicate convergence. However, this is *not* in general the best idea. For some problems and some iterative methods, you could experience iterates *stagnating* but the solution *not converging*.\n", + "\n", + "Convergence of an iterative solution of a system $A \\mathbf{x} = \\mathbf{b}$ means that:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\lim_{k \\rightarrow \\infty} \\mathbf{x}^k = \\mathbf{x}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The error in the solution is actually $\\mathbf{x}-\\mathbf{x}^k$, but we're looking at $\\mathbf{x}^{k+1}-\\mathbf{x}^k$ for our exit criterion. They are not the same thing and the second could tend to zero (or machine precision) without the first being comparably small.\n", + "\n", + "A discussion of better ways to apply stopping criteria for iterative methods is a more advanced topic than we want cover in this course module. Just keep this in mind as you continue your exploration of numerical methods in the future!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "###### The cell below loads the style of the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/05_relax/05_03_Iterate.This.ipynb b/2-finite-difference-method/lessons/05_relax/05_03_Iterate.This.ipynb new file mode 100644 index 0000000..26ef951 --- /dev/null +++ b/2-finite-difference-method/lessons/05_relax/05_03_Iterate.This.ipynb @@ -0,0 +1,1506 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Relax and hold steady" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ready for more relaxing? This is the third lesson of **Module 5** of the course, exploring solutions to elliptic PDEs.\n", + "In [Lesson 1](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb) and [Lesson 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_02_2D.Poisson.Equation.ipynb) of this module we used the Jacobi method (a relaxation scheme) to iteratively find solutions to Laplace and Poisson equations.\n", + "\n", + "And it worked, so why are we still talking about it? Because the Jacobi method is slow, very slow to converge. It might not have seemed that way in the first two notebooks because we were using small grids, but we did need more than 3,000 iterations to reach the exit criterion while solving the Poisson equation on a $41\\times 41$ grid. \n", + "\n", + "You can confirm this below: using `nx,ny=` $128$ on the Laplace problem of Lesson 1, the Jacobi method requires nearly *20,000* iterations before we reach $10^{-8}$ for the L2-norm of the difference between two iterates. That's a *lot* of iterations!\n", + "\n", + "Now, consider this application: an incompressible Navier-Stokes solver has to ensure that the velocity field is divergence-free at every time step. One of the most common ways to ensure this is to solve a Poisson equation for the pressure field. In fact, the pressure Poisson equation is responsible for the majority of the computational expense of an incompressible Navier-Stokes solver. Imagine having to do 20,000 Jacobi iterations for *every* time step in a fluid-flow problem with many thousands or perhaps millions of grid points!\n", + "\n", + "The Jacobi method is the slowest of all relaxation schemes, so let's learn how to improve on it. In this lesson, we'll study the Gauss-Seidel method—twice as fast as Jacobi, in theory—and the successive over-relaxation (SOR) method. We also have some neat Python tricks lined up for you to get to the solution even faster. Let's go!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test problem" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's use the same example problem as in [Lesson 1](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb): Laplace's equation with boundary conditions\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{gathered}\n", + "p=0 \\text{ at } x=0\\\\\n", + "\\frac{\\partial p}{\\partial x} = 0 \\text{ at } x = L_x\\\\\n", + "p = 0 \\text{ at }y = 0 \\\\\n", + "p = \\sin \\left( \\frac{\\frac{3}{2}\\pi x}{L_x} \\right) \\text{ at } y = L_y\n", + " \\end{gathered}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We import our favorite Python libraries, and also some custom functions that we wrote in [Lesson 1](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb), which we have saved in a 'helper' Python file for re-use. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the font family and size to use for Matplotlib figures.\n", + "pyplot.rcParams['font.family'] = 'serif'\n", + "pyplot.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from helper import laplace_solution, l2_norm, plot_3d" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now have the functions `laplace_solution`, `l2_norm`, and `plot_3d` in our namespace. If you can't remember how they work, just use the Python built-in function `help()` and take advantage of the docstrings. It's a good habit to always write docstrings in your functions, and now you see why!\n", + "\n", + "In this notebook, we are going to use larger grids than before, to better illustrate the speed increases we achieve with different iterative methods. Let's create a $128\\times128$ grid and initialize." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "nx = 128 # number of points in the x direction\n", + "ny = 128 # number of points in the y direction\n", + "Lx = 5.0 # domain length in the x direction\n", + "Ly = 5.0 # domain length in the y direction\n", + "dx = Lx / (nx - 1) # grid spacing in x direction\n", + "dy = Ly / (ny - 1) # grid spacing in y direction\n", + "\n", + "# Create the gridline locations.\n", + "x = numpy.linspace(0.0, Lx, num=nx)\n", + "y = numpy.linspace(0.0, Ly, num=ny)\n", + "\n", + "# Set the initial conditions.\n", + "p0 = numpy.zeros((ny, nx))\n", + "p0[-1, :] = numpy.sin(1.5 * numpy.pi * x / Lx)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We said above that the Jacobi method takes nearly $20,000$ iterations before it satisfies our exit criterion of $10^{-8}$ (L2-norm difference between two consecutive iterations). You'll just have to confirm that now. Have a seat!" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def laplace_2d_jacobi(p0, maxiter=20000, rtol=1e-6):\n", + " \"\"\"\n", + " Solves the 2D Laplace equation on a uniform grid\n", + " with equal grid spacing in both directions\n", + " using Jacobi relaxation method.\n", + " \n", + " The exit criterion of the solver is based on the relative L2-norm\n", + " of the solution difference between two consecutive iterations.\n", + " \n", + " Parameters\n", + " ----------\n", + " p0 : numpy.ndarray\n", + " The initial solution as a 2D array of floats.\n", + " maxiter : integer, optional\n", + " Maximum number of iterations to perform;\n", + " default: 20000.\n", + " rtol : float, optional\n", + " Relative tolerance for convergence;\n", + " default: 1e-6.\n", + " \n", + " Returns\n", + " -------\n", + " p : numpy.ndarray\n", + " The solution after relaxation as a 2D array of floats.\n", + " ite : integer\n", + " The number of iterations performed.\n", + " diff : float\n", + " The final relative L2-norm of the difference.\n", + " \"\"\"\n", + " p = p0.copy()\n", + " diff = rtol + 1.0 # initial difference\n", + " ite = 0 # iteration index\n", + " while diff > rtol and ite < maxiter:\n", + " pn = p.copy()\n", + " # Update the solution at interior points.\n", + " p[1:-1, 1:-1] = 0.25 * (pn[1:-1, :-2] + pn[1:-1, 2:] +\n", + " pn[:-2, 1:-1] + pn[2:, 1:-1])\n", + " # Apply 2nd-order Neumann condition (zero-gradient)\n", + " # at the right boundary.\n", + " p[1:-1, -1] = 0.25 * (2.0 * pn[1:-1, -2] +\n", + " pn[2:, -1] + pn[:-2, -1])\n", + " # Compute the relative L2-norm of the difference.\n", + " diff = l2_norm(p, pn)\n", + " ite += 1\n", + " return p, ite, diff" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jacobi relaxation: 19993 iterations to reach a relative difference of 9.998616841362057e-09\n" + ] + } + ], + "source": [ + "# Compute the solution using Jacobi relaxation method.\n", + "p, ites, diff = laplace_2d_jacobi(p0, maxiter=20000, rtol=1e-8)\n", + "print('Jacobi relaxation: {} iterations '.format(ites) +\n", + " 'to reach a relative difference of {}'.format(diff))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Would we lie to you? $19,993$ iterations before we reach the exit criterion of $10^{-8}$. Yikes!\n", + "\n", + "We can also time how long the Jacobi method takes using the `%%timeit` cell-magic. Go make some tea, because this can take a while—the `%%timeit` magic runs the function a few times and then averages their runtimes to give a more accurate result. \n", + "\n", + "- - -\n", + "##### Notes\n", + "\n", + "1. When using `%%timeit`, the return values of a function (`p` and `iterations` in this case) *won't* be saved.\n", + "\n", + "2. We document our timings below, but your timings can vary quite a lot, depending on your hardware. In fact, you may not even see the same trends (some recent hardware can play some fancy tricks with optimizations that you have no control over).\n", + "- - -\n", + "\n", + "With those caveats, let's give it a shot:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7.15 s ± 659 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "laplace_2d_jacobi(p0, maxiter=20000, rtol=1e-8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The printed result above (and others to come later) is from a 2012 MacBook Pro, powered by a 2.9 GHz Intel Core i7. We tried also on more modern machines, and got conflicting results—like the Gauss-Seidel method being slightly slower than Jacobi, even though it required fewer iterations. Don't get too hung up on this: the hardware optimizations applied by more modern CPUs are varied and make a big difference sometimes.\n", + "\n", + "Meanwhile, let's check the overall accuracy of the numerical calculation by comparing it to the analytical solution." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6.173551335288024e-05" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Compute the analytical solution.\n", + "p_exact = laplace_solution(x, y, Lx, Ly)\n", + "\n", + "# Compute the relative L2-norm of the error.\n", + "l2_norm(p, p_exact)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's a pretty small error. Let's assume it is good enough and focus on speeding up the process." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gauss-Seidel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You will recall from [Lesson 1](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb) that a single Jacobi iteration is written as:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p^{k+1}_{i,j} = \\frac{1}{4} \\left(p^{k}_{i,j-1} + p^k_{i,j+1} + p^{k}_{i-1,j} + p^k_{i+1,j} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The Gauss-Seidel method is a simple tweak to this idea: use updated values of the solution as soon as they are available, instead of waiting for the values in the whole grid to be updated. \n", + "\n", + "If you imagine that we progress through the grid points in the order shown by the arrow in Figure 1, then you can see that the updated values $p^{k+1}_{i-1,j}$ and $p^{k+1}_{i,j-1}$ can be used to calculate $p^{k+1}_{i,j}$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "#### Figure 1. Assumed order of updates on a grid." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The iteration formula for Gauss-Seidel is thus:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p^{k+1}_{i,j} = \\frac{1}{4} \\left(p^{k+1}_{i,j-1} + p^k_{i,j+1} + p^{k+1}_{i-1,j} + p^k_{i+1,j} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "There's now a problem for the Python implementation. You can no longer use NumPy's array operations to evaluate the solution updates. Since Gauss-Seidel requires using values immediately after they're updated, we have to abandon our beloved array operations and return to nested `for` loops. Ugh.\n", + "\n", + "We don't like it, but if it saves us a bunch of time, then we can manage. But does it?\n", + "\n", + "Here's a function to compute the Gauss-Seidel updates using a double loop." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def laplace_2d_gauss_seidel(p0, maxiter=20000, rtol=1e-6):\n", + " \"\"\"\n", + " Solves the 2D Laplace equation on a uniform grid\n", + " with equal grid spacing in both directions\n", + " using Gauss-Seidel relaxation method.\n", + " \n", + " The exit criterion of the solver is based on the relative L2-norm\n", + " of the solution difference between two consecutive iterations.\n", + " \n", + " Parameters\n", + " ----------\n", + " p0 : numpy.ndarray\n", + " The initial solution as a 2D array of floats.\n", + " maxiter : integer, optional\n", + " Maximum number of iterations to perform;\n", + " default: 20000.\n", + " rtol : float, optional\n", + " Relative tolerance for convergence;\n", + " default: 1e-6.\n", + " \n", + " Returns\n", + " -------\n", + " p : numpy.ndarray\n", + " The solution after relaxation as a 2D array of floats.\n", + " ite : integer\n", + " The number of iterations performed.\n", + " diff : float\n", + " The final relative L2-norm of the difference.\n", + " \"\"\"\n", + " ny, nx = p0.shape\n", + " p = p0.copy()\n", + " diff = rtol + 1.0 # initial difference\n", + " ite = 0 # iteration index\n", + " while diff > rtol and ite < maxiter:\n", + " pn = p.copy()\n", + " # Update the solution at interior points.\n", + " for j in range(1, ny - 1):\n", + " for i in range(1, nx - 1):\n", + " p[j, i] = 0.25 * (p[j, i - 1] + p[j, i + 1] +\n", + " p[j - 1, i] + p[j + 1, i])\n", + " # Apply 2nd-order Neumann condition (zero-gradient)\n", + " # at the right boundary.\n", + " for j in range(1, ny - 1):\n", + " p[j, -1] = 0.25 * (2.0 * p[j, -2] +\n", + " p[j - 1, -1] + p[j + 1, -1])\n", + " # Compute the relative L2-norm of the difference.\n", + " diff = l2_norm(p, pn)\n", + " ite += 1\n", + " return p, ite, diff" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We would then run this with the following function call:\n", + "\n", + "```Python\n", + "p, ites, diff = laplace_2d_gauss_seidel(\n", + " p0, maxiter=20000, rtol=1e-8)\n", + "```\n", + "\n", + "But **don't do it**. We did it so that you don't have to! \n", + "\n", + "The solution of our test problem with the Gauss-Seidel method required several thousand fewer iterations than the Jacobi method, but it took nearly *10 minutes* to run on our machine." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### What happened?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you think back to the far off days when you first learned about array operations, you might recall that we discovered that NumPy array operations could drastically improve code performance compared with nested `for` loops. NumPy operations are written in C and pre-compiled, so they are *much* faster than vanilla Python.\n", + "\n", + "But the Jacobi method is not algorithmically optimal, giving slow convergence. We want to take advantage of the faster-converging iterative methods, yet unpacking the array operations into nested loops destroys performance. *What can we do?*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Use Numba!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Numba](https://numba.pydata.org/) is an open-source optimizing compiler for Python. It works by reading Python functions that you give it, and generating a compiled version for you—also called Just-In-Time (JIT) compilation. You can then use the function at performance levels that are close to what you can get with compiled languages (like C, C++ and fortran).\n", + "\n", + "It can massively speed up performance, especially when dealing with loops. Plus, it's pretty easy to use. Like we overheard at a conference: [*Numba is a Big Deal.*](http://twitter.com/lorenaabarba/status/625383941453656065)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Caveat\n", + "\n", + "We encourage everyone following the course to use the [Anaconda Python](https://www.anaconda.com/download/) distribution because it's well put-together and simple to use. If you *haven't* been using Anaconda, that's fine, but let us **strongly** suggest that you take the plunge now. Numba is great and easy to use, but it is **not** easy to install without help. Those of you using Anaconda can install it by running:\n", + "\n", + "`conda install numba`\n", + "\n", + "If you *really* don't want to use Anaconda, you will have to [compile all of Numba's dependencies](https://pypi.python.org/pypi/numba).\n", + "\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Intro to Numba" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's dive in! Numba is great and easy to use. We're going to first walk you through a simple example to give you a taste of Numba's abilities. \n", + "\n", + "After installing Numba (see above), we can use it by adding a line to `import numba` and another to `import autojit` (more on this in a bit)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import numba\n", + "from numba import jit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You tell Numba which functions you want to accelerate by using a [Python decorator](http://www.learnpython.org/en/Decorators), a special type of command that tells the Python interpreter to modify a callable object (like a function). For example, let's write a quick function to calculate the $n^{\\text{th}}$ number in the Fibonacci sequence:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def fib_it(n):\n", + " a, b = 1, 1\n", + " for i in range(n - 2):\n", + " a, b = b, a + b\n", + " return b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are several faster ways to program the Fibonacci sequence, but that's not a concern right now (but if you're curious, [check them out](http://mathworld.wolfram.com/BinetsFibonacciNumberFormula.html)). Let's use `%%timeit` and see how long this simple function takes to find the 500,000-th Fibonacci number." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.19 s ± 172 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "fib_it(500000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's try Numba! Just add the `@jit` decorator above the function name and let's see what happens!" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "@jit\n", + "def fib_it(n):\n", + " a, b = 1, 1\n", + " for i in range(n - 2):\n", + " a, b = b, a + b\n", + " return b" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "318 µs ± 7.73 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "fib_it(500000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Holy cow!* In our machine, that's more than 8,000 times faster!\n", + "\n", + "That warning from `%%timeit` is due to the compilation overhead for Numba. The very first time that it executes the function, it has to compile it, then it caches that code for reuse without extra compiling. That's the 'Just-In-Time' bit. You'll see it disappear if we run `%%timeit` again." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "315 µs ± 4.51 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "fib_it(500000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We would agree if you think that this is a rather artificial example, but the speed-up is very impressive indeed. Just adding the one-word decorator!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Running in `nopython` mode" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Numba is very clever, but it can't optimize everything. When it can't, rather than failing to run, it will fall back to the regular Python, resulting in poor performance again. This can be confusing and frustrating, since you might not know ahead of time which bits of code will speed up and which bits won't.\n", + "\n", + "To avoid this particular annoyance, you can tell Numba to use `nopython` mode. In this case, your code will simply fail if the \"jitted\" function can't be optimized. It's simply an option to give you \"fast or nothing.\"\n", + "\n", + "Use `nopython` mode by adding the following line above the function that you want to JIT-compile:\n", + "\n", + "```Python\n", + "@jit(nopython=True)\n", + "```\n", + "\n", + "Also, you can check [here](https://numba.pydata.org/numba-doc/dev/reference/numpysupported.html) what NumPy features are supported by Numba." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Numba version check\n", + "\n", + "In these examples, we are using the latest (as of publication) version of Numba: 0.39.0. Make sure to upgrade or some of the code examples below may not run." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.39.0\n" + ] + } + ], + "source": [ + "print(numba.__version__)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Back to Jacobi" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "We want to compare the performance of different iterative methods under the same conditions. Because the Gauss-Seidel method forces us to unpack the array operations into nested loops (which are very slow in Python), we use Numba to get the code to perform well. Thus, we need to write a new Jacobi method using for-loops and Numba (instead of NumPy), so we can make meaningful comparisons.\n", + "\n", + "Let's write a \"jitted\" Jacobi with loops." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "@jit(nopython=True)\n", + "def laplace_2d_jacobi(p0, maxiter=20000, rtol=1e-6):\n", + " \"\"\"\n", + " Solves the 2D Laplace equation on a uniform grid\n", + " with equal grid spacing in both directions\n", + " using Jacobi relaxation method.\n", + " \n", + " The exit criterion of the solver is based on the relative L2-norm\n", + " of the solution difference between two consecutive iterations.\n", + " \n", + " Parameters\n", + " ----------\n", + " p0 : numpy.ndarray\n", + " The initial solution as a 2D array of floats.\n", + " maxiter : integer, optional\n", + " Maximum number of iterations to perform;\n", + " default: 20000.\n", + " rtol : float, optional\n", + " Relative tolerance for convergence;\n", + " default: 1e-6.\n", + " \n", + " Returns\n", + " -------\n", + " p : numpy.ndarray\n", + " The solution after relaxation as a 2D array of floats.\n", + " ite : integer\n", + " The number of iterations performed.\n", + " conv : list\n", + " The convergence history as a list of floats.\n", + " \"\"\"\n", + " ny, nx = p0.shape\n", + " p = p0.copy()\n", + " conv = [] # convergence history\n", + " diff = rtol + 1.0 # initial difference\n", + " ite = 0 # iteration index\n", + " while diff > rtol and ite < maxiter:\n", + " pn = p.copy()\n", + " # Update the solution at interior points.\n", + " for j in range(1, ny - 1):\n", + " for i in range(1, nx - 1):\n", + " p[j, i] = 0.25 * (pn[j, i - 1] + pn[j, i + 1] +\n", + " pn[j - 1, i] + pn[j + 1, i])\n", + " # Apply 2nd-order Neumann condition (zero-gradient)\n", + " # at the right boundary.\n", + " for j in range(1, ny - 1):\n", + " p[j, -1] = 0.25 * (2.0 * pn[j, -2] +\n", + " pn[j - 1, -1] + pn[j + 1, -1])\n", + " # Compute the relative L2-norm of the difference.\n", + " diff = numpy.sqrt(numpy.sum((p - pn)**2) / numpy.sum(pn**2))\n", + " conv.append(diff)\n", + " ite += 1\n", + " return p, ite, conv" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jacobi relaxation: 19993 iterations to reach a relative difference of 9.998616841562463e-09\n" + ] + } + ], + "source": [ + "# Compute the solution using Jacobi relaxation method.\n", + "p, ites, conv_jacobi = laplace_2d_jacobi(p0,\n", + " maxiter=20000, rtol=1e-8)\n", + "print('Jacobi relaxation: {} iterations '.format(ites) +\n", + " 'to reach a relative difference of {}'.format(conv_jacobi[-1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.57 s ± 19.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "laplace_2d_jacobi(p0, maxiter=20000, rtol=1e-8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In our old machine, that's faster than the NumPy version of Jacobi, but on some newer machines it might not be. Don't obsess over this: there is much hardware black magic that we cannot control.\n", + "\n", + "Remember that NumPy is a highly optimized library. The fact that we can get competitive execution times with this JIT-compiled code is kind of amazing. Plus(!) now we get to try out those techniques that aren't possible with NumPy array operations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Note\n", + "\n", + "We're also saving the history of the L2-norm of the difference between consecutive iterations. We'll take a look at that once we have a few more methods to compare.\n", + "\n", + "\n", + "##### Challenge task\n", + "\n", + "It is possible to get a good estimate of the number of iterations needed by the Jacobi method to reduce the initial error by a factor $10^{-m}$, for given $m$. The formula depends on the largest eigenvalue of the coefficient matrix, which is known for the discrete Poisson problem on a square domain. See Parviz Moin, *\"Fundamentals of Engineering Numerical Analysis\"* (2nd ed., pp.141–143).\n", + "\n", + "* Find the estimated number of iterations to reduce the initial error by $10^{-8}$ when using the grids listed below, in the section on grid convergence, with $11$, $21$, $41$ and $81$ grid points on each coordinate axis." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Back to Gauss-Seidel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you recall, the reason we got into this Numba sidetrack was to try out Gauss-Seidel and compare the performance with Jacobi. Recall from above that the formula for Gauss-Seidel is as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p^{k+1}_{i,j} = \\frac{1}{4} \\left(p^{k+1}_{i,j-1} + p^k_{i,j+1} + p^{k+1}_{i-1,j} + p^k_{i+1,j} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We only need to slightly tweak the Jacobi function to get one for Gauss-Seidel. Instead of updating `p` in terms of `pn`, we just update `p` using `p`!" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "@jit(nopython=True)\n", + "def laplace_2d_gauss_seidel(p0, maxiter=20000, rtol=1e-6):\n", + " \"\"\"\n", + " Solves the 2D Laplace equation on a uniform grid\n", + " with equal grid spacing in both directions\n", + " using Gauss-Seidel relaxation method.\n", + " \n", + " The exit criterion of the solver is based on the relative L2-norm\n", + " of the solution difference between two consecutive iterations.\n", + " \n", + " Parameters\n", + " ----------\n", + " p0 : numpy.ndarray\n", + " The initial solution as a 2D array of floats.\n", + " maxiter : integer, optional\n", + " Maximum number of iterations to perform;\n", + " default: 20000.\n", + " rtol : float, optional\n", + " Relative tolerance for convergence;\n", + " default: 1e-6.\n", + " \n", + " Returns\n", + " -------\n", + " p : numpy.ndarray\n", + " The solution after relaxation as a 2D array of floats.\n", + " ite : integer\n", + " The number of iterations performed.\n", + " conv : list\n", + " The convergence history as a list of floats.\n", + " \"\"\"\n", + " ny, nx = p0.shape\n", + " p = p0.copy()\n", + " conv = [] # convergence history\n", + " diff = rtol + 1.0 # initial difference\n", + " ite = 0 # iteration index\n", + " while diff > rtol and ite < maxiter:\n", + " pn = p.copy()\n", + " # Update the solution at interior points.\n", + " for j in range(1, ny - 1):\n", + " for i in range(1, nx - 1):\n", + " p[j, i] = 0.25 * (p[j, i - 1] + p[j, i + 1] +\n", + " p[j - 1, i] + p[j + 1, i])\n", + " # Apply 2nd-order Neumann condition (zero-gradient)\n", + " # at the right boundary.\n", + " for j in range(1, ny - 1):\n", + " p[j, -1] = 0.25 * (2.0 * p[j, -2] +\n", + " p[j - 1, -1] + p[j + 1, -1])\n", + " # Compute the relative L2-norm of the difference.\n", + " diff = numpy.sqrt(numpy.sum((p - pn)**2) / numpy.sum(pn**2))\n", + " conv.append(diff)\n", + " ite += 1\n", + " return p, ite, conv" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gauss-Seidel relaxation: 13939 iterations to reach a relative difference of 9.99763565214552e-09\n" + ] + } + ], + "source": [ + "# Compute the solution using Gauss-Seidel relaxation method.\n", + "p, ites, conv_gs = laplace_2d_gauss_seidel(p0,\n", + " maxiter=20000, rtol=1e-8)\n", + "print('Gauss-Seidel relaxation: {} iterations '.format(ites) +\n", + " 'to reach a relative difference of {}'.format(conv_gs[-1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cool! Using the most recently updated values of the solution in the Gauss-Seidel method saved 6,000 iterations! Now we can see how much faster than Jacobi this is, because both methods are implemented the same way:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.41 s ± 113 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "laplace_2d_gauss_seidel(p0, maxiter=20000, rtol=1e-8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We get no speed-up over the Numba version of Jacobi, and you may see different results. On some of the machines we tried, we could not beat the NumPy version of Jacobi. This can be confusing, and hard to explain without getting into the nitty grity of hardware optimizations.\n", + "\n", + "Don't lose hope! We have another trick up our sleeve!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Successive Over-Relaxation (SOR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Successive over-relaxation is able to improve on the Gauss-Seidel method by using in the update a linear combination of the previous and the current solution, as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "p^{k+1}_{i,j} = (1 - \\omega)p^k_{i,j} + \\frac{\\omega}{4} \\left(p^{k+1}_{i,j-1} + p^k_{i,j+1} + p^{k+1}_{i-1,j} + p^k_{i+1,j} \\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The relaxation parameter $\\omega$ will determine how much faster SOR will be than Gauss-Seidel. SOR iterations are only stable for $0 < \\omega < 2$. Note that for $\\omega = 1$, SOR reduces to the Gauss-Seidel method.\n", + "\n", + "If $\\omega < 1$, that is technically an \"under-relaxation\" and it will be slower than Gauss-Seidel. \n", + "\n", + "If $\\omega > 1$, that's the over-relaxation and it should converge faster than Gauss-Seidel. \n", + "\n", + "Let's write a function for SOR iterations of the Laplace equation, using Numba to get high performance." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "@jit(nopython=True)\n", + "def laplace_2d_sor(p0, omega, maxiter=20000, rtol=1e-6):\n", + " \"\"\"\n", + " Solves the 2D Laplace equation on a uniform grid\n", + " with equal grid spacing in both directions\n", + " using successive over-relaxation (SOR) method.\n", + " \n", + " The exit criterion of the solver is based on the relative L2-norm\n", + " of the solution difference between two consecutive iterations.\n", + " \n", + " Parameters\n", + " ----------\n", + " p0 : numpy.ndarray\n", + " The initial solution as a 2D array of floats.\n", + " omega : float\n", + " Relaxation parameter.\n", + " maxiter : integer, optional\n", + " Maximum number of iterations to perform;\n", + " default: 20000.\n", + " rtol : float, optional\n", + " Relative tolerance for convergence;\n", + " default: 1e-6.\n", + " \n", + " Returns\n", + " -------\n", + " p : numpy.ndarray\n", + " The solution after relaxation as a 2D array of floats.\n", + " ite : integer\n", + " The number of iterations performed.\n", + " conv : list\n", + " The convergence history as a list of floats.\n", + " \"\"\"\n", + " ny, nx = p0.shape\n", + " p = p0.copy()\n", + " conv = [] # convergence history\n", + " diff = rtol + 1.0 # initial difference\n", + " ite = 0 # iteration index\n", + " while diff > rtol and ite < maxiter:\n", + " pn = p.copy()\n", + " # Update the solution at interior points.\n", + " for j in range(1, ny - 1):\n", + " for i in range(1, nx - 1):\n", + " p[j, i] = ((1.0 - omega) * p[j, i] +\n", + " omega * 0.25 *(p[j, i - 1] + p[j, i + 1] +\n", + " p[j - 1, i] + p[j + 1, i]))\n", + " # Apply 2nd-order Neumann condition (zero-gradient)\n", + " # at the right boundary.\n", + " for j in range(1, ny - 1):\n", + " p[j, -1] = 0.25 * (2.0 * p[j, -2] +\n", + " p[j - 1, -1] + p[j + 1, -1])\n", + " # Compute the relative L2-norm of the difference.\n", + " diff = numpy.sqrt(numpy.sum((p - pn)**2) / numpy.sum(pn**2))\n", + " conv.append(diff)\n", + " ite += 1\n", + " return p, ite, conv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That wasn't too bad at all. Let's try this out first with $\\omega = 1$ and check that it matches the Gauss-Seidel results from above." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SOR (omega=1.0): 13939 iterations to reach a relative difference of 9.99763565214552e-09\n" + ] + } + ], + "source": [ + "# Compute the solution using SOR method.\n", + "omega = 1.0\n", + "p, ites, conv_sor = laplace_2d_sor(p0, omega,\n", + " maxiter=20000, rtol=1e-8)\n", + "print('SOR (omega={}): {} iterations '.format(omega, ites) +\n", + " 'to reach a relative difference of {}'.format(conv_sor[-1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have the exact same number of iterations as Gauss-Seidel. That's a good sign that things are working as expected.\n", + "\n", + "Now let's try to over-relax the solution and see what happens. To start, let's try $\\omega = 1.5$." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SOR (omega=1.5): 7108 iterations to reach a relative difference of 9.991011445834247e-09\n" + ] + } + ], + "source": [ + "# Compute the solution using SOR method.\n", + "omega = 1.5\n", + "p, ites, conv_sor = laplace_2d_sor(p0, omega,\n", + " maxiter=20000, rtol=1e-8)\n", + "print('SOR (omega={}): {} iterations '.format(omega, ites) +\n", + " 'to reach a relative difference of {}'.format(conv_sor[-1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wow! That really did the trick! We dropped from $13,939$ iterations down to $7,108$. Now we're really cooking! Let's try `%%timeit` on SOR." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.24 s ± 11.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "laplace_2d_sor(p0, omega, maxiter=20000, rtol=1e-8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Things continue to speed up. But we can do even better!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tuned SOR" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Above, we picked $\\omega=1.5$ arbitrarily, but we would like to over-relax the solution as much as possible without introducing instability, as that will result in the fewest number of iterations.\n", + "\n", + "For square domains, it turns out that the ideal factor $\\omega$ can be computed as a function of the number of nodes in one direction, e.g., `nx`.\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\omega \\approx \\frac{2}{1+\\frac{\\pi}{nx}}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "This is not some arbitrary formula, but its derivation lies outside the scope of this course. (If you're curious and have some serious math chops, you can check out Reference 3 for more information). For now, let's try it out and see how it works." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SOR (omega=1.9521): 1110 iterations to reach a relative difference of 9.964283931955807e-09\n" + ] + } + ], + "source": [ + "# Compute the solution using tuned SOR method.\n", + "omega = 2.0 / (1.0 + numpy.pi / nx)\n", + "p, ites, conv_opt_sor = laplace_2d_sor(p0, omega,\n", + " maxiter=20000, rtol=1e-8)\n", + "print('SOR (omega={:.4f}): {} iterations '.format(omega, ites) +\n", + " 'to reach a relative difference of {}'.format(conv_opt_sor[-1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wow! That's *very* fast. Also, $\\omega$ is very close to the upper limit of 2. SOR tends to work fastest when $\\omega$ approaches 2, but don't be tempted to push it. Set $\\omega = 2$ and the walls will come crumbling down.\n", + "\n", + "Let's see what `%%timeit` has for us now." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "196 ms ± 2.71 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "laplace_2d_sor(p0, omega, maxiter=20000, rtol=1e-8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Regardless of the hardware in which we tried this, the tuned SOR gave *big* speed-ups, compared to the Jacobi method (whether implemented with NumPy or Numba). Now you know why we told you at the end of [Lesson 1](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb) that the Jacobi method is the *worst* iterative solver and almost never used.\n", + "\n", + "Just to convince ourselves that everything is OK, let's check the error after the $1,110$ iterations of tuned SOR:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7.792743355069158e-05" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Compute the relative L2-norm of the error.\n", + "l2_norm(p, p_exact)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looking very good, indeed.\n", + "\n", + "We didn't explain it in any detail, but notice the very interesting implication of Equation $(6)$: the ideal relaxation factor is a function of the grid size. \n", + "Also keep in mind that the formula only works for square domains with uniform grids. If your problem has an irregular geometry, you will need to find a good value of $\\omega$ by numerical experiments." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Decay of the difference between iterates" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the [Poisson Equation notebook](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_02_2D.Poisson.Equation.ipynb), we noticed how the norm of the difference between consecutive iterations first dropped quite fast, then settled for a more moderate decay rate. With Gauss-Seidel, SOR and tuned SOR, we reduced the number of iterations required to reach the stopping criterion. Let's see how that reflects on the time history of the difference between consecutive solutions." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the convergence history for different methods.\n", + "pyplot.figure(figsize=(9.0, 4.0))\n", + "pyplot.xlabel('Iterations')\n", + "pyplot.ylabel('Relative $L_2$-norm\\nof the difference')\n", + "pyplot.grid()\n", + "pyplot.semilogy(conv_jacobi, label='Jacobi')\n", + "pyplot.semilogy(conv_gs, label='Gauss-Seidel')\n", + "pyplot.semilogy(conv_sor, label='SOR')\n", + "pyplot.semilogy(conv_opt_sor, label='Optimized SOR')\n", + "pyplot.legend()\n", + "pyplot.xlim(0, 20000);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Jacobi method starts out with very fast convergence, but then it settles into a slower rate. Gauss-Seidel shows a faster rate in the first few thousand iterations, but it seems to be slowing down towards the end. SOR is a lot faster to converge, though, and optimized SOR just plunges down!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. [Gonsalves, Richard J. Computational Physics I. State University of New York, Buffalo: (2011): Section 3.1 ](http://www.physics.buffalo.edu/phy410-505/2011/index.html)\n", + "\n", + "2. Moin, Parviz, \"Fundamentals of Engineering Numerical Analysis,\" Cambridge University Press, 2nd edition (2010).\n", + "\n", + "3. Young, David M. \"A bound for the optimum relaxation factor for the successive overrelaxation method.\" Numerische Mathematik 16.5 (1971): 408-413." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "###### The cell below loads the style of this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "hide_input": true, + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/05_relax/05_04_Conjugate.Gradient.ipynb b/2-finite-difference-method/lessons/05_relax/05_04_Conjugate.Gradient.ipynb new file mode 100644 index 0000000..1fff852 --- /dev/null +++ b/2-finite-difference-method/lessons/05_relax/05_04_Conjugate.Gradient.ipynb @@ -0,0 +1,977 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license © 2015 L.A. Barba, G.F. Forsyth, B. Knaepen" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Relax and hold steady" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is the fourth and last notebook of **Module 5** (*\"Relax and hold steady\"*), dedicated to elliptic PDEs. In the [previous notebook](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_03_Iterate.This.ipynb), we examined how different algebraic formulations can speed up the iterative solution of the Laplace equation, compared to the simplest (but slowest) Jacobi method. The Gauss-Seidel and successive-over relaxation methods both provide faster algebraic convergence than Jacobi. But there is still room for improvement. \n", + "\n", + "In this lesson, we'll take a look at the very popular [conjugate gradient](https://en.wikipedia.org/wiki/Conjugate_gradient_method) (CG) method. \n", + "The CG method solves linear systems with coefficient matrices that are symmetric and positive-definite. It is either used on its own, or in conjunction with multigrid—a technique that we'll explore later on its own (optional) course module.\n", + "\n", + "For a real understanding of the CG method, there is no better option than studying the now-classic monograph by Jonathan Shewchuck: *\"An introduction to the conjugate gradient method without the agonizing pain\"* (1994). Here, we try to give you a brief summary to explain the implementation in Python." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test problem" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's return to the Poisson equation example from [Lesson 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_02_2D.Poisson.Equation.ipynb).\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla^2 p = -2\\left(\\frac{\\pi}{2}\\right)^2\\sin\\left( \\frac{\\pi x}{L_x} \\right) \\cos\\left(\\frac{\\pi y}{L_y}\\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "in the domain \n", + "\n", + "$$\n", + "\\left\\lbrace \\begin{align*}\n", + "0 &\\leq x\\leq 1 \\\\\n", + "-0.5 &\\leq y \\leq 0.5 \n", + "\\end{align*} \\right.\n", + "$$\n", + "\n", + "where $L_x = L_y = 1$ and with boundary conditions \n", + "\n", + "$$\n", + "p=0 \\text{ at } \\left\\lbrace \n", + "\\begin{align*}\n", + "x&=0\\\\\n", + "y&=0\\\\\n", + "y&=-0.5\\\\\n", + "y&=0.5\n", + "\\end{align*} \\right.\n", + "$$\n", + "\n", + "We will solve this equation by assuming an initial state of $p=0$ everywhere, and applying boundary conditions to relax via the Laplacian operator." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Head in the right direction!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recall that in its discretized form, the Poisson equation reads,\n", + "\n", + "$$\n", + "\\frac{p_{i+1,j}^{k}-2p_{i,j}^{k}+p_{i-1,j}^{k}}{\\Delta x^2}+\\frac{p_{i,j+1}^{k}-2 p_{i,j}^{k}+p_{i,j-1}^{k}}{\\Delta y^2}=b_{i,j}^{k}\n", + "$$\n", + "\n", + "The left hand side represents a linear combination of the values of $p$ at several grid points and this linear combination has to be equal to the value of the source term, $b$, on the right hand side.\n", + "\n", + "Now imagine you gather the values $p_{i,j}$ of $p$ at all grid points into a big vector ${\\bf p}$ and you do the same for $b$ using the same ordering. Both vectors ${\\bf p}$ and ${\\bf b}$ contain $N=nx*ny$ values and thus belong to $\\mathbb{R}^N$. The discretized Poisson equation corresponds to the following linear system:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "A{\\bf p}={\\bf b},\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $A$ is an $N\\times N$ matrix. Although we will not directly use the matrix form of the system in the CG algorithm, it is useful to examine the problem this way to understand how the method works.\n", + "\n", + "All iterative methods start with an initial guess, $\\mathbf{p}^0$, and modify it in a way such that we approach the solution. This can be viewed as modifying the vector of discrete $p$ values on the grid by adding another vector, i.e., taking a step of magnitude $\\alpha$ in a direction $\\mathbf{d}$, as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "{\\bf p}^{k+1}={\\bf p}^k + \\alpha {\\bf d}^k\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The iterations march towards the solution by taking steps along the direction vectors ${\\bf d}^k$, with the scalar $\\alpha$ dictating how big a step to take at each iteration. We *could* converge faster to the solution if we just knew how to carefully choose the direction vectors and the size of the steps. But how to do that?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The residual" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the tools we use to find the right direction to step to is called the *residual*. What is the residual? We're glad you asked!\n", + "\n", + "We know that, as the iterations proceed, there will be some error between the calculated value, $p^k_i$, and the exact solution $p^{exact}_i$. We may not know what the exact solution is, but we know it's out there. The error is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "e^k_i = p^k_i - p^{exact}_i\n", + "\\end{equation}\n", + "$$\n", + "\n", + "**Note:** We are talking about error at a specific point $i$, not a measure of error across the entire domain. \n", + "\n", + "What if we recast the Poisson equation in terms of a not-perfectly-relaxed $\\bf p^k$?\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "A \\bf p^k \\approx b\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We write this as an approximation because $\\bf p^k \\neq p$. To \"fix\" the equation, we need to add an extra term to account for the difference in the Poisson equation $-$ that extra term is called the residual. We can write out the modified Poisson equation like this:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "{\\bf r^k} + A \\bf p^k = b\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The method of steepest descent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before considering the more-complex CG algorithm, it is helpful to introduce a simpler approach called the *method of steepest descent*. At iteration $0$, we choose an initial guess. Unless we are immensely lucky, it will not satisfy the Poisson equation and we will have,\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "{\\bf b}-A{\\bf p}^0={\\bf r}^0\\ne {\\bf 0}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The vector ${\\bf r}^0$ is the initial residual and measures how far we are from satisfying the linear system. We can monitor the residual vector at each iteration, as it gets (hopefully) smaller and smaller: \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "{\\bf r}^k={\\bf b}-A{\\bf p}^k\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We make two choices in the method of steepest descent:\n", + "\n", + "1. the direction vectors are the residuals ${\\bf d}^k = {\\bf r}^k$, and\n", + "2. the length of the step makes the $k+1^{th}$ residual orthogonal to the $k^{th}$ residual.\n", + "\n", + "There are good (not very complicated) reasons to justify these choices and you should read one of the references to understand them. But since we want you to converge to the end of the notebook in a shorter time, please accept them for now. \n", + "\n", + "Choice 2 requires that,\n", + "\n", + "$$\n", + "\\begin{align}\n", + "{\\bf r}^{k+1}\\cdot {\\bf r}^{k} = 0 \\nonumber \\\\\n", + "\\Leftrightarrow ({\\bf b}-A{\\bf p}^{k+1}) \\cdot {\\bf r}^{k} = 0 \\nonumber \\\\\n", + "\\Leftrightarrow ({\\bf b}-A({\\bf p}^{k}+\\alpha {\\bf r}^k)) \\cdot {\\bf r}^{k} = 0 \\nonumber \\\\\n", + "\\Leftrightarrow ({\\bf r}^k-\\alpha A{\\bf r}^k) \\cdot {\\bf r}^{k} = 0 \\nonumber \\\\\n", + "\\alpha = \\frac{{\\bf r}^k \\cdot {\\bf r}^k}{A{\\bf r}^k \\cdot {\\bf r}^k}.\n", + "\\end{align}\n", + "$$\n", + "\n", + "We are now ready to test this algorithm.\n", + "\n", + "To begin, let's import libraries and some helper functions and set up our mesh." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from helper import l2_norm, poisson_2d_jacobi, poisson_solution" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "nx = 101 # number of points in the x direction\n", + "ny = 101 # number of points in the y direction\n", + "xmin, xmax = 0.0, 1.0 # limits in the x direction\n", + "ymin, ymax = -0.5, 0.5 # limits in the y direction\n", + "Lx = xmax - xmin # domain length in the x direction\n", + "Ly = ymax - ymin # domain length in the y direction\n", + "dx = Lx / (nx - 1) # grid spacing in the x direction\n", + "dy = Ly / (ny - 1) # grid spacing in the y direction\n", + "\n", + "# Create the gridline locations and the mesh grid.\n", + "x = numpy.linspace(xmin, xmax, num=nx)\n", + "y = numpy.linspace(ymin, ymax, num=ny)\n", + "X, Y = numpy.meshgrid(x, y)\n", + "\n", + "# Create the source term.\n", + "b = (-2.0 * (numpy.pi / Lx) * (numpy.pi / Ly) *\n", + " numpy.sin(numpy.pi * X / Lx) *\n", + " numpy.cos(numpy.pi * Y / Ly))\n", + "\n", + "# Set the initial conditions.\n", + "p0 = numpy.zeros((ny, nx))\n", + "\n", + "# Compute the analytical solution.\n", + "p_exact = poisson_solution(x, y, Lx, Ly)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Time to code steepest descent! \n", + "\n", + "Let's quickly review the solution process:\n", + "\n", + "1. Calculate the residual, $\\bf r^k$, which also serves as the direction vector, $\\bf d^k$\n", + "2. Calculate the step size $\\alpha$\n", + "3. Update ${\\bf p}^{k+1}={\\bf p}^k + \\alpha {\\bf d}^k$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### How do we calculate the residual? \n", + "\n", + "We have an equation for the residual above:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "{\\bf r}^k={\\bf b}-A{\\bf p}^k\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Remember that $A$ is just a stand-in for the discrete Laplacian, which taking $\\Delta x=\\Delta y$ is:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla^2 p^k = \\frac{-4p^k_{i,j} + \\left(p^{k}_{i,j-1} + p^k_{i,j+1} + p^{k}_{i-1,j} + p^k_{i+1,j} \\right)}{\\Delta x^2}\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### What about calculating $\\alpha$?\n", + "\n", + "The calculation of $\\alpha$ is relatively straightforward, but does require evaluating the term $A{\\bf r^k}$, but we just wrote the discrete $A$ operator above. You just need to apply that same formula to $\\mathbf{r}^k$." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def poisson_2d_steepest_descent(p0, b, dx, dy,\n", + " maxiter=20000, rtol=1e-6):\n", + " \"\"\"\n", + " Solves the 2D Poisson equation on a uniform grid,\n", + " with the same grid spacing in both directions,\n", + " for a given forcing term\n", + " using the method of steepest descent.\n", + " \n", + " The function assumes Dirichlet boundary conditions with value zero.\n", + " The exit criterion of the solver is based on the relative L2-norm\n", + " of the solution difference between two consecutive iterations.\n", + "\n", + " Parameters\n", + " ----------\n", + " p0 : numpy.ndarray\n", + " The initial solution as a 2D array of floats.\n", + " b : numpy.ndarray\n", + " The forcing term as a 2D array of floats.\n", + " dx : float\n", + " Grid spacing in the x direction.\n", + " dy : float\n", + " Grid spacing in the y direction.\n", + " maxiter : integer, optional\n", + " Maximum number of iterations to perform;\n", + " default: 20000.\n", + " rtol : float, optional\n", + " Relative tolerance for convergence;\n", + " default: 1e-6.\n", + "\n", + " Returns\n", + " -------\n", + " p : numpy.ndarray\n", + " The solution after relaxation as a 2D array of floats.\n", + " ite : integer\n", + " The number of iterations performed.\n", + " conv : list\n", + " The convergence history as a list of floats.\n", + " \"\"\"\n", + " def A(p):\n", + " # Apply the Laplacian operator to p.\n", + " return (-4.0 * p[1:-1, 1:-1] +\n", + " p[1:-1, :-2] + p[1:-1, 2:] +\n", + " p[:-2, 1:-1] + p[2:, 1:-1]) / dx**2\n", + " p = p0.copy()\n", + " r = numpy.zeros_like(p) # initial residual\n", + " Ar = numpy.zeros_like(p) # to store the mat-vec multiplication\n", + " conv = [] # convergence history\n", + " diff = rtol + 1 # initial difference\n", + " ite = 0 # iteration index\n", + " while diff > rtol and ite < maxiter:\n", + " pk = p.copy()\n", + " # Compute the residual.\n", + " r[1:-1, 1:-1] = b[1:-1, 1:-1] - A(p)\n", + " # Compute the Laplacian of the residual.\n", + " Ar[1:-1, 1:-1] = A(r)\n", + " # Compute the step size.\n", + " alpha = numpy.sum(r * r) / numpy.sum(r * Ar)\n", + " # Update the solution.\n", + " p = pk + alpha * r\n", + " # Dirichlet boundary conditions are automatically enforced.\n", + " # Compute the relative L2-norm of the difference.\n", + " diff = l2_norm(p, pk)\n", + " conv.append(diff)\n", + " ite += 1\n", + " return p, ite, conv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see how it performs on our example problem." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Method of steepest descent: 2 iterations to reach a relative difference of 1.3307695446303778e-16\n" + ] + } + ], + "source": [ + "# Compute the solution using the method of steepest descent.\n", + "p, ites, conv_sd = poisson_2d_steepest_descent(p0, b, dx, dy,\n", + " maxiter=20000,\n", + " rtol=1e-10)\n", + "print('Method of steepest descent: {} iterations '.format(ites) +\n", + " 'to reach a relative difference of {}'.format(conv_sd[-1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8.225076220929745e-05" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Compute the relative L2-norm of the error.\n", + "l2_norm(p, p_exact)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Not bad! it took only *two* iterations to reach a solution that meets our exit criterion. Although this seems great, the steepest descent algorithm is not too good when used with large systems or more complicated right-hand sides in the Poisson equation (we'll examine this below!). We can get better performance if we take a little more care in selecting the direction vectors, $\\bf d^k$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The method of conjugate gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With steepest descent, we know that two **successive** jumps are orthogonal, but that's about it. There is nothing to prevent the algorithm from making several jumps in the same (or a similar) direction. Imagine you wanted to go from the intersection of 5th Avenue and 23rd Street to the intersection of 9th Avenue and 30th Street. Knowing that each segment has the same computational cost (one iteration), would you follow the red path or the green path?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Figure 1. Do you take the red path or the green path?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "variables": { + "\\bf r}^{k+1} \\cdot {\\bf r}^{k+1": {} + } + }, + "source": [ + "The method of conjugate gradients reduces the number of jumps by making sure the algorithm never selects the same direction twice. The size of the jumps is now given by:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\alpha = \\frac{{\\bf r}^k \\cdot {\\bf r}^k}{A{\\bf d}^k \\cdot {\\bf d}^k}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "and the direction vectors by:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "{\\bf d}^{k+1}={\\bf r}^{k+1}+\\beta{\\bf d}^{k}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $\\beta = \\frac{{\\bf r}^{k+1} \\cdot {\\bf r}^{k+1}}{{\\bf r}^k \\cdot {\\bf r}^k}$.\n", + "\n", + "The search directions are no longer equal to the residuals but are instead a linear combination of the residual and the previous search direction. It turns out that CG converges to the exact solution (up to machine accuracy) in a maximum of $N$ iterations! When one is satisfied with an approximate solution, many fewer steps are needed than with any other method. Again, the derivation of the algorithm is not immensely difficult and can be found in Shewchuk (1994)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Implementing Conjugate Gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "variables": { + "\\bf r}^{k+1} \\cdot {\\bf r}^{k+1": {} + } + }, + "source": [ + "We will again update $\\bf p$ according to \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "{\\bf p}^{k+1}={\\bf p}^k + \\alpha {\\bf d}^k\n", + "\\end{equation}\n", + "$$\n", + "\n", + "but use the modified equations above to calculate $\\alpha$ and ${\\bf d}^k$. \n", + "\n", + "You may have noticed that $\\beta$ depends on both ${\\bf r}^{k+1}$ and ${\\bf r}^k$ and that makes the calculation of ${\\bf d}^0$ a little bit tricky. Or impossible (using the formula above). Instead we set ${\\bf d}^0 = {\\bf r}^0$ for the first step and then switch for all subsequent iterations. \n", + "\n", + "Thus, the full set of steps for the method of conjugate gradients is:\n", + "\n", + "Calculate ${\\bf d}^0 = {\\bf r}^0$ (just once), then\n", + "\n", + "1. Calculate $\\alpha = \\frac{{\\bf r}^k \\cdot {\\bf r}^k}{A{\\bf d}^k \\cdot {\\bf d}^k}$\n", + "2. Update ${\\bf p}^{k+1}$\n", + "3. Calculate ${\\bf r}^{k+1} = {\\bf r}^k - \\alpha A {\\bf d}^k$ $\\ \\ \\ \\ $(see Shewchuk (1994))\n", + "4. Calculate $\\beta = \\frac{{\\bf r}^{k+1} \\cdot {\\bf r}^{k+1}}{{\\bf r}^k \\cdot {\\bf r}^k}$\n", + "5. Calculate ${\\bf d}^{k+1}={\\bf r}^{k+1}+\\beta{\\bf d}^{k}$\n", + "6. Repeat!" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def poisson_2d_conjugate_gradient(p0, b, dx, dy,\n", + " maxiter=20000, rtol=1e-6):\n", + " \"\"\"\n", + " Solves the 2D Poisson equation on a uniform grid,\n", + " with the same grid spacing in both directions,\n", + " for a given forcing term\n", + " using the method of conjugate gradients.\n", + " \n", + " The function assumes Dirichlet boundary conditions with value zero.\n", + " The exit criterion of the solver is based on the relative L2-norm\n", + " of the solution difference between two consecutive iterations.\n", + "\n", + " Parameters\n", + " ----------\n", + " p0 : numpy.ndarray\n", + " The initial solution as a 2D array of floats.\n", + " b : numpy.ndarray\n", + " The forcing term as a 2D array of floats.\n", + " dx : float\n", + " Grid spacing in the x direction.\n", + " dy : float\n", + " Grid spacing in the y direction.\n", + " maxiter : integer, optional\n", + " Maximum number of iterations to perform;\n", + " default: 20000.\n", + " rtol : float, optional\n", + " Relative tolerance for convergence;\n", + " default: 1e-6.\n", + "\n", + " Returns\n", + " -------\n", + " p : numpy.ndarray\n", + " The solution after relaxation as a 2D array of floats.\n", + " ite : integer\n", + " The number of iterations performed.\n", + " conv : list\n", + " The convergence history as a list of floats.\n", + " \"\"\"\n", + " def A(p):\n", + " # Apply the Laplacian operator to p.\n", + " return (-4.0 * p[1:-1, 1:-1] +\n", + " p[1:-1, :-2] + p[1:-1, 2:] +\n", + " p[:-2, 1:-1] + p[2:, 1:-1]) / dx**2\n", + " p = p0.copy()\n", + " r = numpy.zeros_like(p) # initial residual\n", + " Ad = numpy.zeros_like(p) # to store the mat-vec multiplication\n", + " conv = [] # convergence history\n", + " diff = rtol + 1 # initial difference\n", + " ite = 0 # iteration index\n", + " # Compute the initial residual.\n", + " r[1:-1, 1:-1] = b[1:-1, 1:-1] - A(p)\n", + " # Set the initial search direction to be the residual.\n", + " d = r.copy()\n", + " while diff > rtol and ite < maxiter:\n", + " pk = p.copy()\n", + " rk = r.copy()\n", + " # Compute the Laplacian of the search direction.\n", + " Ad[1:-1, 1:-1] = A(d)\n", + " # Compute the step size.\n", + " alpha = numpy.sum(r * r) / numpy.sum(d * Ad)\n", + " # Update the solution.\n", + " p = pk + alpha * d\n", + " # Update the residual.\n", + " r = rk - alpha * Ad\n", + " # Update the search direction.\n", + " beta = numpy.sum(r * r) / numpy.sum(rk * rk)\n", + " d = r + beta * d\n", + " # Dirichlet boundary conditions are automatically enforced.\n", + " # Compute the relative L2-norm of the difference.\n", + " diff = l2_norm(p, pk)\n", + " conv.append(diff)\n", + " ite += 1\n", + " return p, ite, conv" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Method of conjugate gradients: 2 iterations to reach a relative difference of 1.2982770796281907e-16\n" + ] + } + ], + "source": [ + "# Compute the solution using the method of conjugate gradients.\n", + "p, ites, conv_cg = poisson_2d_conjugate_gradient(p0, b, dx, dy,\n", + " maxiter=20000,\n", + " rtol=1e-10)\n", + "print('Method of conjugate gradients: {} iterations '.format(ites) +\n", + " 'to reach a relative difference of {}'.format(conv_cg[-1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8.225076220929585e-05" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Compute the relative L2-norm of the error.\n", + "l2_norm(p, p_exact)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The method of conjugate gradients also took two iterations to reach a solution that meets our exit criterion. But let's compare this to the number of iterations needed for the Jacobi iteration:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jacobi relaxation: 31227 iterations to reach a relative difference of 9.997923503623598e-11\n" + ] + } + ], + "source": [ + "# Compute the solution using Jacobi relaxation.\n", + "p, ites, conv_jacobi = poisson_2d_jacobi(p0, b, dx, dy,\n", + " maxiter=40000,\n", + " rtol=1e-10)\n", + "print('Jacobi relaxation: {} iterations '.format(ites) +\n", + " 'to reach a relative difference of {}'.format(conv_jacobi[-1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For our test problem, we get substantial gains in terms of computational cost using the method of steepest descent or the conjugate gradient method." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## More difficult Poisson problems" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The conjugate gradient method really shines when one needs to solve more difficult Poisson problems. To get an insight into this, let's solve the Poisson problem using the same boundary conditions as the previous problem but with the following right-hand side,\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "b = \\sin\\left(\\frac{\\pi x}{L_x}\\right) \\cos\\left(\\frac{\\pi y}{L_y}\\right) + \\sin\\left(\\frac{6\\pi x}{L_x}\\right) \\cos\\left(\\frac{6\\pi y}{L_y}\\right)\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Modify the source term of the Poisson system.\n", + "b = (numpy.sin(numpy.pi * X / Lx) *\n", + " numpy.cos(numpy.pi * Y / Ly) +\n", + " numpy.sin(6.0 * numpy.pi * X / Lx) *\n", + " numpy.cos(6.0 * numpy.pi * Y / Ly))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jacobi relaxation: 31226 iterations\n", + "Method of steepest descent: 31591 iterations\n", + "Method of conjugate gradients: 72 iterations\n" + ] + } + ], + "source": [ + "maxiter, rtol = 40000, 1e-10\n", + "p, ites, conv = poisson_2d_jacobi(p0, b, dx, dy,\n", + " maxiter=maxiter, rtol=rtol)\n", + "print('Jacobi relaxation: {} iterations'.format(ites))\n", + "p, ites, conv = poisson_2d_steepest_descent(p0, b, dx, dy,\n", + " maxiter=maxiter,\n", + " rtol=rtol)\n", + "print('Method of steepest descent: {} iterations'.format(ites))\n", + "p, ites, conv = poisson_2d_conjugate_gradient(p0, b, dx, dy,\n", + " maxiter=maxiter,\n", + " rtol=rtol)\n", + "print('Method of conjugate gradients: {} iterations'.format(ites))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can really appreciate the marvel of the CG method!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Shewchuk, J. (1994). [An Introduction to the Conjugate Gradient Method Without the Agonizing Pain (PDF)](http://www.cs.cmu.edu/~quake-papers/painless-conjugate-gradient.pdf)\n", + "\n", + "Ilya Kuzovkin, [The Concept of Conjugate Gradient Descent in Python](http://ikuz.eu/2015/04/15/the-concept-of-conjugate-gradient-descent-in-python/)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "###### The cell below loads the style of this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3 (MAE6286)", + "language": "python", + "name": "py36-mae6286" + }, + "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.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/2-finite-difference-method/lessons/05_relax/05_05_Stokes.Flow.ipynb b/2-finite-difference-method/lessons/05_relax/05_05_Stokes.Flow.ipynb new file mode 100644 index 0000000..26f0f7c --- /dev/null +++ b/2-finite-difference-method/lessons/05_relax/05_05_Stokes.Flow.ipynb @@ -0,0 +1,620 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Relax and hold steady" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Stokes flow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook presents the coding assignment for **Module 5** of the course [*\"Practical Numerical Methods with Python.*](https://github.com/numerical-mooc/numerical-mooc) Your mission is to solve Stokes flow in a square cavity, using the vorticity-streamfunction formulation.\n", + "\n", + "Stokes flow, also known as *creeping flow*, refers to flows that are dominated by viscous forces and not by the advective/convective forces. The Stokes-flow assumption works well for flows that have very low Reynolds number, much smaller than 1: very slow, highly viscous or flows at microscopic length scales.\n", + "\n", + "Stokes flow allows us to simplify the Navier-Stokes equations, eliminating the non-linearity. Let's run through a quick derivation of the vorticity-transport equation with Stokes-flow assumptions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Vorticity" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start with the Navier-Stokes equations for incompressible flow:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial u}{\\partial t} + u \\cdot \\nabla u = -\\frac{1}{\\rho}\\nabla p + \\nu\\nabla^2 u\n", + "\\end{equation}\n", + "$$\n", + "\n", + "If we scale Equation $(1)$ to make it non-dimensional, we can rewrite it as\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "Re \\left(\\frac{\\partial u^*}{\\partial t} + u^* \\cdot \\nabla u^* \\right) = -\\nabla p^* + \\nabla^2 u^*\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Where $u^*$ and $p^*$ are the non-dimensional velocity and pressure, respectively. \n", + "\n", + "To obtain Stokes flow, we assume that the Reynolds number approaches zero. Applying that assumption to Equation $(2)$ and dropping the stars, yields\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "0 = - \\nabla p + \\nabla^2 u\n", + "\\end{equation}\n", + "$$\n", + "\n", + "That simplified things! Now, we apply the curl operator on both sides of the equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla \\times 0 = \\nabla \\times \\left( - \\nabla p + \\nabla^2 u\\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "The left-hand side remains zero, while the first term on the right-hand side is\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla \\times - \\nabla p = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "because $\\nabla \\times \\nabla \\phi = 0$ where $\\phi$ is a scalar.\n", + "\n", + "Finally,\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla \\times \\nabla^2 u =\\nabla^2\\omega\n", + "\\end{equation}\n", + "$$\n", + "\n", + "where $\\nabla \\times u = \\omega$ is the vorticity. \n", + "\n", + "Combining all of these equations, we arrive at the simplified vorticity transport equation for Stokes flow:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla ^2 \\omega = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Look familiar?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Stream function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the stream function $\\psi$, such that\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "u = \\frac{\\partial \\psi}{\\partial y} \\text{ and } v = - \\frac{\\partial \\psi}{\\partial x}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "In 2D, we can write out the vorticity as\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\omega = \\frac{\\partial v}{\\partial x} - \\frac{\\partial u}{\\partial y}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "which, combined with the previous equation yields another familiar looking equation:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla^2 \\psi = -\\omega\n", + "\\end{equation}\n", + "$$\n", + "\n", + "We have a system of two coupled equations that can describe the fluid flow in a lid-driven cavity at very low Reynolds numbers. \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla^2 \\omega = 0\n", + "\\end{equation}\n", + "$$\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla^2 \\psi = -\\omega\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Note that by substituting Equation $(12)$ into $(11)$, we arrive at a new equation: the *biharmonic equation*:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\nabla^4 \\psi= 0\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Solving the biharmonic equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Is it possible to discretize a 4th-order partial differential equation? Of course! Are we going to? No!\n", + "\n", + "There's nothing wrong with a 4th-order equation, but in this course module we learned about the Poisson equation and that's what we're going to use. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cavity flow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You will solve a problem called *lid-driven cavity flow*. This is a common test problem for Navier-Stokes solvers—we'll be using it to examine Stokes flow. \n", + "\n", + "Assume that the lid of a square cavity moves at a constant velocity of $u=1$, with no fluid leaking out past the moving lid. We we want to visualize what the flow field inside the cavity looks like at steady state. \n", + "\n", + "All of the surfaces, including the lid, are assumed to have no-slip boundary conditions. The boundary conditions are all specified in terms of the streamfunction $\\psi$, as shown below in Figure $(1)$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Figure 1. Lid-driven Cavity Flow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Boundary conditions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the major hurdles with the vorticity-streamfunction formulation is the treatment of boundary conditions. \n", + "\n", + "The boundary conditions are all specified in terms of $\\psi$ and its derivatives, but the Laplace equation\n", + "\n", + "$$\n", + "\\nabla \\omega^2 = 0\n", + "$$\n", + "\n", + "has no $\\psi$ value. Instead, we need a way to represent the boundary conditions for $\\omega$ in terms of $\\psi$. \n", + "\n", + "Consider the equation $\\nabla ^2 \\psi = -\\omega$ along the top surface of the cavity (the moving surface). The streamfunction $\\psi$ along $x$-direction is a zero constant, so $\\frac{\\partial ^2 \\psi}{\\partial x^2}$ goes to zero and the equation simplifies to\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial ^2 \\psi}{\\partial y^2} = -\\omega\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A 2nd-order central difference discretization gives\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\omega_j = - \\left(\\frac{\\psi_{j+1} - 2\\psi_j + \\psi_{j-1}}{\\Delta y^2}\\right)\n", + "\\end{equation}\n", + "$$\n", + "\n", + "but the value $\\psi_{j+1}$ is outside of the domain. Now take a 3rd-order discretization of $\\frac{\\partial \\psi}{\\partial y}$ evaluated along the top edge.\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\left.\\frac{\\partial \\psi}{\\partial y}\\right|_j = \\frac{2\\psi_{j+1} + 3\\psi_j - 6\\psi_{j-1} + \\psi_{j-2}}{6 \\Delta y}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "$\\frac{\\partial \\psi}{\\partial y}$ is a given boundary value in the problem along the top edge\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\left.\\frac{\\partial \\psi}{\\partial y}\\right|_j = u_j\n", + "\\end{equation}\n", + "$$\n", + "\n", + "which leaves us with a value for $\\psi_{j+1}$ that consists only of points within the domain. \n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\psi_{j+1} = \\frac{6\\Delta y u_j - 3\\psi_j + 6 \\psi_{j-1} - \\psi_{j-2}}{2}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Plug in that result into the initial discretization from Equation $(15)$ and we have a boundary condition for $\\omega$ along the top surface in terms of $\\psi$:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\omega_{i,j} = -\\frac{1}{2 \\Delta y^2} (8\\psi_{i, j-1} - \\psi_{i, j-2}) - \\frac{3u_j}{\\Delta y} + \\mathcal{O}(\\Delta y^2)\n", + "\\end{equation}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Coding assignment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Solve Stokes flow in a lid-driven cavity using the parameters given below. \n", + "\n", + "You should iteratively solve for both $\\omega$ and $\\psi$ until the L1 norm of the difference between successive iterations is less than $1$$\\tt{E}$$^-6$ for **both** quantities. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters.\n", + "nx, ny = 41, 41 # number of points in each direction\n", + "L = 1.0 # length of the square cavity\n", + "dx = L / (nx - 1) # grid spacing in the x direction\n", + "dy = L / (ny - 1) # grid spacing in the y direction" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def l1_norm(u, u_ref):\n", + " \"\"\"\n", + " Computes and returns the L1-norm of the difference\n", + " between a solution u and a reference solution u_ref.\n", + "\n", + " Parameters\n", + " ----------\n", + " u : numpy.ndarray\n", + " The solution as an array of floats.\n", + " u_ref : numpy.ndarray\n", + " The reference solution as an array of floats.\n", + "\n", + " Returns\n", + " -------\n", + " diff : float\n", + " The L2-norm of the difference.\n", + " \"\"\"\n", + " diff = numpy.sum(numpy.abs(u - u_ref))\n", + " return diff" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The final result should resemble the plot shown in Figure $(2)$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The boundary conditions for $\\omega$ depend upon the current value of $\\psi$. The two equations are *coupled*. If you try to solve them in a *uncoupled* way, things will go poorly." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Figure 2. Contour plot of streamfunction at steady state" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Fletcher, C. A. (1988). Computational Techniques for Fluid Dynamics: Volume 2: Specific Techniques for Different Flow Categories.\n", + "\n", + "* Ghia, U. K. N. G., Ghia, K. N., & Shin, C. T. (1982). High-Re solutions for incompressible flow using the Navier-Stokes equations and a multigrid method. Journal of computational physics, 48(3), 387-411.\n", + "\n", + "* Greenspan, D. (1974). Discrete numerical methods in physics and engineering (Vol. 312). New York: Academic Press.\n", + "\n", + "* Heil, Matthias (2007). [Viscous Fluid Flow Vorticity Handout (pdf)](http://www.maths.manchester.ac.uk/~mheil/Lectures/Fluids/Material_2007/Vorticity.pdf)\n", + "\n", + "* Non-dimensionalization and scaling of the Navier Stokes equations. (n.d.). In *Wikipedia*. Retrieved January 30, 2015 [http://en.wikipedia.org/w/index.php?title=Non-dimensionalization_and_scaling_of_the_Navier-Stokes_equations](http://en.wikipedia.org/w/index.php?title=Non-dimensionalization_and_scaling_of_the_Navier%E2%80%93Stokes_equations&oldid=641860920)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "###### The cell below loads the style of this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import HTML\n", + "css_file = '../../styles/numericalmoocstyle.css'\n", + "HTML(open(css_file, 'r').read())" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3 (MOOC)", + "language": "python", + "name": "py36-mooc" + }, + "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.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/2-finite-difference-method/lessons/05_relax/README.md b/2-finite-difference-method/lessons/05_relax/README.md new file mode 100644 index 0000000..c595cd6 --- /dev/null +++ b/2-finite-difference-method/lessons/05_relax/README.md @@ -0,0 +1,25 @@ +# Module 5: +## Relax and hold steady: elliptic problems +## Summary +This course module is dedicated to the solution of elliptic PDS, like the Laplace and Poisson equations. +These equations have no time dependence and the solutions can be found by iterative schemes, where an +initial guess is relaxed to the steady-state solution. + +* [Lesson 1](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb) +introduces the five-point discrete Laplace operator and the Jacobi method. We solve a 2D Laplace problem +with both Dirichlet and Neumann boundary conditions. Via a spatial grid-convergence analysis, we find that the Neumann +boundary conditions needs a second-order difference approximation to get second-order spatial convergence throughout. + +* [Lesson 2](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_02_2D.Poisson.Equation.ipynb) +is dedicated to the Poisson equation: we see the effect of having internal sources with an elliptic equation. +We also learn about algebraic convergence of iterative methods and protest at how slow the Jacobi method is. + +* In [lesson 3](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_03_Iterate.This.ipynb) +we improve on the Jacobi method: we look at Gauss-Seidel and successive over-relaxation (SOR) schemes. +We also learn about **Numba**, an optimizing compiler that gives us high performance in Python. + +* [Lesson 4](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_04_Conjugate.Gradient.ipynb) +focuses on the conjugate gradient (CG) method, perhaps the most popular iterative method. + +* The [Coding Assignment](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_05_Stokes.Flow.ipynb) +for Module 5 consists of solving the Stokes equation for flow in a square cavity at very low Reynolds number. diff --git a/2-finite-difference-method/lessons/05_relax/data/relaxation_schedules.npz b/2-finite-difference-method/lessons/05_relax/data/relaxation_schedules.npz new file mode 100644 index 0000000..2c8d3b6 Binary files /dev/null and b/2-finite-difference-method/lessons/05_relax/data/relaxation_schedules.npz differ diff --git a/2-finite-difference-method/lessons/05_relax/figures/drivencavity.svg b/2-finite-difference-method/lessons/05_relax/figures/drivencavity.svg new file mode 100644 index 0000000..587de7a --- /dev/null +++ b/2-finite-difference-method/lessons/05_relax/figures/drivencavity.svg @@ -0,0 +1,1029 @@ + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/05_relax/figures/jumps.png b/2-finite-difference-method/lessons/05_relax/figures/jumps.png new file mode 100644 index 0000000..db62d6a Binary files /dev/null and b/2-finite-difference-method/lessons/05_relax/figures/jumps.png differ diff --git a/2-finite-difference-method/lessons/05_relax/figures/laplace.svg b/2-finite-difference-method/lessons/05_relax/figures/laplace.svg new file mode 100644 index 0000000..aca274b --- /dev/null +++ b/2-finite-difference-method/lessons/05_relax/figures/laplace.svg @@ -0,0 +1,577 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/05_relax/figures/solvepath.svg b/2-finite-difference-method/lessons/05_relax/figures/solvepath.svg new file mode 100644 index 0000000..8865d3d --- /dev/null +++ b/2-finite-difference-method/lessons/05_relax/figures/solvepath.svg @@ -0,0 +1,624 @@ + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/05_relax/figures/stokes_contour.svg b/2-finite-difference-method/lessons/05_relax/figures/stokes_contour.svg new file mode 100644 index 0000000..539b525 --- /dev/null +++ b/2-finite-difference-method/lessons/05_relax/figures/stokes_contour.svg @@ -0,0 +1,2371 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/2-finite-difference-method/lessons/05_relax/helper.py b/2-finite-difference-method/lessons/05_relax/helper.py new file mode 100644 index 0000000..5d6a042 --- /dev/null +++ b/2-finite-difference-method/lessons/05_relax/helper.py @@ -0,0 +1,178 @@ +""" +Helper functions for lessons of module 5 of Numerical-MOOC. +""" + +import numpy +from matplotlib import pyplot, cm +from mpl_toolkits import mplot3d + + +def laplace_solution(x, y, Lx, Ly): + """ + Computes and returns the analytical solution of the Laplace equation + on a given two-dimensional Cartesian grid. + + Parameters + ---------- + x : numpy.ndarray + The gridline locations in the x direction + as a 1D array of floats. + y : numpy.ndarray + The gridline locations in the y direction + as a 1D array of floats. + Lx : float + Length of the domain in the x direction. + Ly : float + Length of the domain in the y direction. + + Returns + ------- + p : numpy.ndarray + The analytical solution as a 2D array of floats. + """ + X, Y = numpy.meshgrid(x, y) + p = (numpy.sinh(1.5 * numpy.pi * Y / Ly) / + numpy.sinh(1.5 * numpy.pi * Ly / Lx) * + numpy.sin(1.5 * numpy.pi * X / Lx)) + return p + + +def poisson_solution(x, y, Lx, Ly): + """ + Computes and returns the analytical solution of the Poisson equation + on a given two-dimensional Cartesian grid. + + Parameters + ---------- + x : numpy.ndarray + The gridline locations in the x direction + as a 1D array of floats. + y : numpy.ndarray + The gridline locations in the y direction + as a 1D array of floats. + Lx : float + Length of the domain in the x direction. + Ly : float + Length of the domain in the y direction. + + Returns + ------- + p : numpy.ndarray + The analytical solution as a 2D array of floats. + """ + X, Y = numpy.meshgrid(x, y) + p = numpy.sin(numpy.pi * X / Lx) * numpy.cos(numpy.pi * Y / Ly) + return p + + +def l2_norm(p, p_ref): + """ + Computes and returns the relative L2-norm of the difference + between a solution p and a reference solution p_ref. + If L2(p_ref) = 0, the function simply returns + the L2-norm of the difference. + + Parameters + ---------- + p : numpy.ndarray + The solution as an array of floats. + p_ref : numpy.ndarray + The reference solution as an array of floats. + + Returns + ------- + diff : float + The (relative) L2-norm of the difference. + """ + l2_diff = numpy.sqrt(numpy.sum((p - p_ref)**2)) + l2_ref = numpy.sqrt(numpy.sum(p_ref**2)) + if l2_ref > 1e-12: + return l2_diff / l2_ref + return l2_diff + + +def poisson_2d_jacobi(p0, b, dx, dy, maxiter=20000, rtol=1e-6): + """ + Solves the 2D Poisson equation for a given forcing term + using Jacobi relaxation method. + + The function assumes Dirichlet boundary conditions with value zero. + The exit criterion of the solver is based on the relative L2-norm + of the solution difference between two consecutive iterations. + + Parameters + ---------- + p0 : numpy.ndarray + The initial solution as a 2D array of floats. + b : numpy.ndarray + The forcing term as a 2D array of floats. + dx : float + Grid spacing in the x direction. + dy : float + Grid spacing in the y direction. + maxiter : integer, optional + Maximum number of iterations to perform; + default: 20000. + rtol : float, optional + Relative tolerance for convergence; + default: 1e-6. + + Returns + ------- + p : numpy.ndarray + The solution after relaxation as a 2D array of floats. + ite : integer + The number of iterations performed. + conv : list + The convergence history as a list of floats. + """ + p = p0.copy() + conv = [] # convergence history + diff = rtol + 1.0 # initial difference + ite = 0 # iteration index + while diff > rtol and ite < maxiter: + pn = p.copy() + p[1:-1, 1:-1] = (((pn[1:-1, :-2] + pn[1:-1, 2:]) * dy**2 + + (pn[:-2, 1:-1] + pn[2:, 1:-1]) * dx**2 - + b[1:-1, 1:-1] * dx**2 * dy**2) / + (2.0 * (dx**2 + dy**2))) + # Dirichlet boundary conditions at automatically enforced. + # Compute and record the relative L2-norm of the difference. + diff = l2_norm(p, pn) + conv.append(diff) + ite += 1 + return p, ite, conv + + +def plot_3d(x, y, p, label='$z$', elev=30.0, azim=45.0): + """ + Creates a Matplotlib figure with a 3D surface plot of the scalar field p. + + Parameters + ---------- + x : numpy.ndarray + Gridline locations in the x direction as a 1D array of floats. + y : numpy.ndarray + Gridline locations in the y direction as a 1D array of floats. + p : numpy.ndarray + Scalar field to plot as a 2D array of floats. + label : string, optional + Axis label to use in the third direction; + default: 'z'. + elev : float, optional + Elevation angle in the z plane; + default: 30.0. + azim : float, optional + Azimuth angle in the x,y plane; + default: 45.0. + """ + fig = pyplot.figure(figsize=(8.0, 6.0)) + ax = mplot3d.Axes3D(fig) + ax.set_xlabel('$x$') + ax.set_ylabel('$y$') + ax.set_zlabel(label) + X, Y = numpy.meshgrid(x, y) + ax.plot_surface(X, Y, p, cmap=cm.viridis) + ax.set_xlim(x[0], x[-1]) + ax.set_ylim(y[0], y[-1]) + ax.view_init(elev=elev, azim=azim) diff --git a/2-finite-difference-method/lessons/05_relax/multigrid_helper.py b/2-finite-difference-method/lessons/05_relax/multigrid_helper.py new file mode 100644 index 0000000..39d4fec --- /dev/null +++ b/2-finite-difference-method/lessons/05_relax/multigrid_helper.py @@ -0,0 +1,108 @@ +import numpy +from numba import autojit + +@autojit(nopython=True) +def poisson1d_GS_SingleItr(nx, dx, p, b): + ''' + Gauss-Seidel method for 1D Poisson eq. with Dirichlet BCs at both + ends. Only a single iteration is executed. **blitz** is used. + + Parameters: + ---------- + nx: int, number of grid points in x direction + dx: float, grid spacing in x + p: 1D array of float, approximated soln. in last iteration + b: 1D array of float, 0th-order derivative term in Poisson eq. + + Returns: + ------- + p: 1D array of float, approximated soln. in current iteration + ''' + + for i in range(1,len(p)-1): + p[i] = 0.5 * (p[i+1] + p[i-1] - dx**2 * b[i]) + + return p + + + +def RMS(p): + ''' + Return the root mean square of p. + + Parameters: + ---------- + p: array + + Returns: + ------- + Root mean square of p + ''' + return numpy.sqrt(numpy.sum(p**2) / p.size) + + + +def residual(dx, pn, b, r): + ''' + Calculate the residual for the 1D Poisson equation. + + Parameters: + ---------- + pn: 1D array, approximated solution at a certain iteration n + b: 1D array, the b(x) in the Poisson eq. + + Return: + ---------- + The residual r + ''' + + # r[0] = 0 + r[1:-1] = b[1:-1] - (pn[:-2] - 2 * pn[1:-1] + pn[2:]) / dx**2 + # r[-1] = 0 + + return r + + + +def full_weighting_1d(vF, vC): + ''' + Transfer a vector on a fine grid to a coarse grid with full weighting + . The number of elements (not points) of the coarse grid is + half of that of the fine grid. + + Parameters: + ---------- + vF: 1D numpy array, the vector on the fine grid + vC: 1D numpy array, the vector on the coarse grid, + size(vC) = (size(vF) + 1) / 2 + + Output: vC + ''' + + vC[0] = vF[0] + vC[1:-1] = 0.25 * (vF[1:-3:2] + 2. * vF[2:-2:2] + vF[3:-1:2]) + vC[-1] = vF[-1] + + return vC + + + +def interpolation_1d(vC, vF): + ''' + Transfer a vector on a coarse grid to a fine grid by linear + interpolation. The number of elements (not points) of the coarse + grid is a half of that of the fine grid. + + Parameters: + ---------- + vC: 1D numpy array, the vector on the coarse grid, + vF: 1D numpy array, the vector on the fine grid + size(vF) = size(vC) * 2 - 1 + + Output: vF + ''' + + vF[::2] = vC[:]; + vF[1:-1:2] = 0.5 * (vC[:-1] + vC[1:]) + + return vF diff --git a/2-finite-difference-method/nm_python_env.yaml b/2-finite-difference-method/nm_python_env.yaml new file mode 100644 index 0000000..688466f --- /dev/null +++ b/2-finite-difference-method/nm_python_env.yaml @@ -0,0 +1,47 @@ +name: py3mooc +dependencies: +- certifi=14.05.14=py34_0 +- fastcache=1.0.2=py34_0 +- fontconfig=2.11.1=4 +- freetype=2.5.2=2 +- ipython=3.2.0=py34_0 +- ipython-notebook=3.2.0=py34_0 +- jinja2=2.7.3=py34_1 +- jsonschema=2.4.0=py34_0 +- libpng=1.6.17=0 +- libsodium=0.4.5=0 +- libxml2=2.9.2=0 +- llvmlite=0.6.0=py34_0 +- markupsafe=0.23=py34_0 +- matplotlib=1.4.3=np19py34_2 +- mistune=0.6=py34_0 +- numba=0.20.0=np19py34_0 +- numpy=1.9.2=py34_0 +- openssl=1.0.1k=1 +- pip=7.1.0=py34_0 +- ptyprocess=0.4=py34_0 +- pygments=2.0.2=py34_0 +- pyparsing=2.0.3=py34_0 +- pyqt=4.11.3=py34_1 +- python=3.4.3=1 +- python-dateutil=2.4.2=py34_0 +- pytz=2015.4=py34_0 +- pyzmq=14.7.0=py34_0 +- qt=4.8.6=3 +- readline=6.2=2 +- scipy=0.15.1=np19py34_0 +- setuptools=18.0.1=py34_0 +- sip=4.16.5=py34_0 +- six=1.9.0=py34_0 +- sqlite=3.8.4.1=1 +- sympy=0.7.6=py34_0 +- system=5.8=2 +- terminado=0.5=py34_0 +- tk=8.5.18=0 +- tornado=4.2=py34_0 +- xz=5.0.5=0 +- zeromq=4.0.5=0 +- zlib=1.2.8=0 +- pip: + - jsanimation==0.1 + diff --git a/2-finite-difference-method/styles/numericalmoocstyle.css b/2-finite-difference-method/styles/numericalmoocstyle.css new file mode 100644 index 0000000..23eb13e --- /dev/null +++ b/2-finite-difference-method/styles/numericalmoocstyle.css @@ -0,0 +1,158 @@ + + + + + + + + +