Chapter 6. Parallel Processing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 6: High Performance Computing\n",
    "Module 5 of Phys212/Biol212 class\n",
    "### by Ilya Nemenman, 2016-2020"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining High Performance Computing\n",
    "\n",
    "Nowadays news are full with articles about new technological breakthroughs in artificial intelligence: self-driving cars, automatic translation, and even computer-generated art. What makes all of this possible, among other things, is a dramatic increase in our computational capabilities in the last decade. Interestingly, the speed of computer processors has not changed that much over this time -- an individual processor now is only a bit faster than is used to be ten years ago. What has changed is that we figured out how to put more processors into a single computer (and sometimes dramatically more -- literally thousands of specialized processors in some video cards) and how to make all of these processors to work collectively on solving large computational problems we want to solve. In this module, we discuss the basics of such parallel computing and will figure out how to implement it on your laptops.\n",
    "\n",
    "<font color='pink'>**ToDo**: need to expand the introduction by adding a few paragraphs on history of HPC</font>\n",
    "\n",
    "What is high performance computing? To answer this, we need to define a series of terms. \n",
    " - **<font color='red'>Processor</font>**, or Central Processing Unit (**CPU**): The *brain* of the computer, the part in which most computing operations are controlled and executed. \n",
    " - **<font color='red'>Serial Processing</font>**: Execution of a single program step by step on one CPU.\n",
    " - **<font color='red'>Sequential Processing</font>**: Execution of multiple programs on a single CPU in a sequence.\n",
    " - **<font color='red'>Concurrent Processing</font>**: Execution of multiple programs at the same time. \n",
    " - **<font color='red'>Parallel Processing</font>**: Execution of multiple programs (or parts of the same one) on multiple CPUs. \n",
    " - **<font color='red'>High Performance Computing</font>**: It is basically another name for solving computational problems concurrently on multiple CPUs.\n",
    "Note that different books define some of these terms differently. However, for this class, we will stick with the definitions above.\n",
    " \n",
    "It gets a bit more complicated than these simple definitions. For example, one can have serial and sequential processing (completing one task before starting the other on a single CPU). One can also have serial and concurrent processing (alternating between two or more tasks on the same single CPU). Finally, one can have true parallel and concurrent processing, which means executing multiple tasks simultaneously at the same instant of time on multiple CPUs.\n",
    "<font color='pink'>**ToDo**: Show picture of different execution formats</font>\n",
    "\n",
    "### Organization of Parallel Computing\n",
    "What are the different ways of organizing parallel processing? We can develop the intuition by considering how you can arrange for multiple people in a group to do a certain complex task that consists of many different subtasks. For example, let's suppose that a group of people are arriving to a supermarket to buy a long list of supplies for a party. It seems reasonable to suppose that many people should be able to complete the shopping process faster than one, but this would require some additional organization to split the overall shopping list into sub-components. How can we organize people to do this? There are many different ways of doing this.\n",
    " - The simplest option is not to delegate different parts of the shopping list to different people, but to have just one person to complete all of the steps of the task, while others wait. This is equivalent to sequential processing. The advantages are clearly seen -- we do not need to think how to delegate tasks. Thus, for a short shopping list, this may be the fastest solution -- instead of spending time figuring out who buys what, one person quickly runs into the store and returns. However, for long shopping lists, the disadvantage is also clear -- we are not using the additional processing power of the entire team, and hence get no speedup compared to how long it would take a single person to shop.\n",
    " - The second option is to have the group captain assign a list of subtasks to each of the people in the group, and let them all focus on each of their assigned tasks. This incurs communication cost. First, the partitioning of the full list of tasks into pieces must be done, and then these sublists must be communicated to the people.  When they complete their individual tasks, the results of the completion must be communicated to the leader. This communication/organization takes time in its own right, and may make parallel processing not very efficient. Further, there are additional inefficiencies. While the task is being partitioned, the people will be waiting for their assignments, doing nothing. Then some of them will finish their subtasks before the others, and will again wait, doing nothing. However, for a long shopping list, with a smart enough partitioning of tasks that tries to balance the complexity of individual assignments, such parallel shopping can result in a substantial speedup.\n",
    " - To avoid wasting time when an individual completes their task, the arrangement above may possibly be improved. For example, when a person finishes his/her task, s/he may be asked to help the others who are still doing theirs. However, this is easier said then done. Whom should they help? To know this, each person must be constantly communicating his/her progress, either broadcasting it to everyone in the group, or at least sending it to the captain. In the former case, everyone would know who needs help. In the latter, everyone who needs more work would contact the capatain for additional instructions. In either case, communication would become a significant bottleneck: either everyone is listening to messages from everyone else (potentially having little time to do actual work!), or a captain may get overwhelmed in keeping track of everyone's progress. In addition, in either case, when help arrives, the task of a worker who is running behind needs to be partitioned again, which will take yet additional time and resources. At some point all of these communication costs may not be worth it!\n",
    " - To avoid some of these problems, one may want to duplicate the tasks originally, but prioritize them, so that every person first works on his/her task. And when those are completed, one then switches on the next pre-assigned task, constantly reporting progress. You can fill in the gaps of what kind of problems -- and which communication costs -- this solution carries.\n",
    " - Another interesting approach to explore is to have a more hierarchical structure of parallel processing. The first agent may look at the shooping list, and decide that the list is too long to be shopping alone. The agent then divides the list in half, and recruits one additional helper and gives half of the list to him/her. Then the process repeats: both the original agent and the recruit evaluate their capabilties against the job assigned to them, and, if needed, divide their list further into two parts, and recruit additional helpers. This goes on and on, until either the individual shopping assignements are small enough so that recruiting additional help is useless, or until no more free helpers are left. Again, you can fill in the gaps regarding which kind of problems one would experience with this solution\n",
    " \n",
    ">### Your turn 6.1\n",
    "Suggest one other arrangement not discussed in the lecture notes of how tasks can be divided among multiple workers. \n",
    "\n",
    "Note that, in all of these suggestiong (and any of your additional ones), the more complicated the arrangement is, the more communication needs to be done. And communication takes time -- so that, at a certain point, communication costs outweigh the savings one will generate from a complex task-partitioning scheme. This is, unfortunately, the law of parallel processing: simple parallel schemes are inefficient because they do not utilize all of the available resources, and complex schemes are inefficient because they spend too much time on arranging for efficient utilization, rather than actually doing the work. There's often a goldilocks zone, where efficiency is good enough, and communication costs are small enough, for the computation to be the fastest. Landing in this zone is usually the goal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With these different arrangements, it makes sense to have a bit finer characterization of concurrent / parallel processing, which, as always, requires more definitions. \n",
    " - **<font color ='red'>Parallel processing</font>** per se: Collection of connected, tightly coupled, strongly communicating processors concurrently solving a problem.\n",
    " - **<font color ='red'>Distributed processing</font>**: Loosely coupled processors, perhaps great distances from each other, working concurrently on problems with minimal communication among them.\n",
    "These definitions are a bit sloppy (e.g., what is \"strongly\" vs \"loosely\" connected?) -- but we will have to live with them.\n",
    "\n",
    "True parallel processing is further distinguished by how memory of the computers is organized\n",
    " - **<font color ='red'>Shared memory</font>**: Parallel processors access the same memory during concurrent processing, requiring minimal communication beyond the shared memory.\n",
    " - **<font color ='red'>Distributed memory</font>**: Each processor has its own memory to operate with, and synchronization of tasks is achieved through communication.\n",
    " \n",
    "In this Module, we will focus on *parallel* processing rather than on *distributed* processing -- so that tasks we will complete will be executed on a single computer (usually your laptop) with multiple CPUs (usually two or four in modern laptop computers). Since all of these CPUs have access to the same memory, it meand that we will be writing the *shared memory* parallel processing programs. \n",
    "\n",
    "Crucially, a program written for sequential processing will not execute easily on many processors. It needs to be **<font color='red'>parallelized</font>**, aka **<font color='red'>scaled</font>**, to many processors. This usually involves careful consideration of how concurrent processing is to be organized, how the tasks are to be partitioned, how multiple data streams and execution streams are to be synchronized, how communication is to be arranged, etc. After all is said and done, the program will usually run faster on multiple processors than on a single one, but the costs of parallelization will not be negligible. To understand how useful parallelization is for a specific program, a useful metric is the **<font color='red'>speedup</font>**, which is the ratio of the time it takes to execute a parallelized  program on $n$ processors compared to the time it takes to execute  a sequential version of the task on just one CPU. The speedup of larger than $n$ is essentially impossible to acheive on any but very contrived tasks. Moreover, the speedup is usually less than $n$ (and often *a lot* less than $n$) due to communication costs. \n",
    "\n",
    "\n",
    ">### <font color='green'>Track 2: Logical vs. physical CPUs </font> \n",
    "<font color ='pink'>**ToDo**: add the discussion.</font> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Types of parallel algorithms\n",
    "<font color='pink'>**ToDo(*: need pictures of different parallelization schemes.</font>\n",
    "\n",
    "Some problems are easier to parallelize than others, and different approaches are required for parallelization.  For example, if we need to generate many realizations of a process (e.g., recall looking at the variance of many realizations of random walks in the previous chapter), then this is very essy to parallelize -- each of the $n$ available CPUs generates the fraction of the needed data, and this requires very little communication between the processors to achieve, likely resulting in a speedup of almost $n$. On the contrary, if we want to simulate a complex fluid flow, by assigning different processors to compute motion of different parts of the fluid, then the processors must communicate constantly: fluid motionis continuous, and fluid leaving one subvolume must re-emerge on the other. This problem will be much more difficult to parallelize.  \n",
    "\n",
    "Overall, we will distinguish the following types of parallelization schemes:\n",
    " - **<font color='red'>Embarrassingly parallel algorithms</font>**: The task can be divided into subtasks that have virtually no communication. As hinted above, typically problems such as generating statistics (e.g., producing many DLA clusters of Module 4) are embarrassingly parallelizable. For example, you could have run multiple Jupyter notebooks at the same time, and each would produce a single cluster, whose horizontal extent can then be averaged.\n",
    " - **<font color='red'>Data partitioning algorithms</font>**: Here the task can be partitioned into subtasks, where the same type of a computation is performed for each of the subtasks, but on different subsets of data. Typically a special privileged *root* process performs the partitioning, and the communication among the subtasks is also handled by the root. As an example, consider calculating a sum of a large array. The data set can be partitioned into parts (by the root), each part can be summed independently, and then the subsums can be added by the root. \n",
    " - **<font color='red'>Divide and conquer algorithms</font>**: Here work is done without a root. Instead, as in the last example about shopping above, each processor gets a task and, if it can't execute it in a requested time, it subdivides the task into two, leaves one half for itself, and recruits another processor for the remaining half. Both of the processors then continue doing the same, until each of the recruited processors has a manageable task. When the tasks are completed, each processor reports its results to the processor who originally gave it the task. \n",
    " - **<font color='red'>Coarsening algorithms</font>**: This is a very special parallelization scheme, only applicable to various multiscale physical systems. Here the processors work on partitioned data, but solve the problem on multiple scales. For example, in a fluid flow problem, one set of processors may track fluctuations in the speed of the fluid flow on the scale of centimeters, and then report to a (smaller) set of processors that track fluctuations on scales of meters, and so on. We will not consider examples of this parallelization scheme in this course. \n",
    "\n",
    "For all of these algorithms, it is crucial to think how the data must be organized to speed up communication, and we will devote a lot of time to these questions. Often even the very choice of the paralllelization scheme would depend on these mundane considerations about the organization and the communication."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problems to be solved with parallel processing\n",
    "\n",
    "Which problems can be solved faster using multiple processors? Embarrasingly parallel algorithms are very good for generating a lot of statistics. They often (though not always) work great for agent-based simulations, if agents do not interact a lot. However, they are not good for spatially extended problems, or cellular automata problems. Such problems that we discussed (e.g., DLA, annihilation) can be solved by data partitioning, where each one of the processors analyzes a sub-part of the lattice, and the communication among the processors is very limited, only happening at the edges of the sub-lattices where they meet. \n",
    "\n",
    "There is a special type of cellular automata, for which parallel processing is usually used (and, in fact, was developed for originally). These emerge from simulations of what is known as **<font color='red'>partial differential equations</font>**, that is, differential equation that contains unknown multivariable functions and their derivatives with respect to many variables. For example, consider a situation where one is trying to predict weather, or, for simplicity, just the temperature $T$ over some extended spatial range, which is what weather forcasters routinely do. Now the variable $T$ that we care about depends on the spatial coordinates in addition to time, $T=T(x,y,z,t)$. This is in contrast to all previous examples we considered, where the dynamical variables were few, and they depended just on time, such as the coordinate and the angular velocity of the pendulum, $\\theta(t), \\omega(t)$, or the concentration of nutrients and the number of bacteria, $\\rho(t),n(t)$. Variable that are space and time dependent, like the temperature, are known as **<font color='red'>field</font>**. On a digital computer, we usually approximate the continuous coordinates $x,y,z$ as a grid, and so $T(x,y,z,t)$ becomes a set of variables $T(x_i,y_j,z_k,t)$, with the dimensionality of the set being $N=\\frac{L_x}{\\Delta x}\\frac{L_y}{\\Delta y}\\frac{L_z}{\\Delta z}\\sim \\left(\\frac{L_x}{\\Delta x}\\right)^d$, where $L_x$ is the linear span of the system, $\\Delta x$ is the lattice spacing (and similarly for $y$ and $z$), and $d=3$ is the dimension. Even for a reazonably small $\\frac{L_x}{\\Delta x}\\sim 100$, the number of dynamical variables we need to store to describe the dynamics of $T$ is then $N\\sim 10^6$. That is, the spatially extended dynamical system is equivalent to a dynamical system with very many (potentially millions or billions) of dynamical variables. As you have observed earlier, solving ODEs for even a few dynamical variables can take a substantial amount of time. It is also clear that this time complexity is going to scale as, at least, $O(N)$, and potentially even worse if many variables interact with each other. Thus the need to use all of the available computational resources (and hence parallelizing the code) for such spatially extended simulations is clear. We will introduce one of such partial differential equations automata here, the *heat diffusion equation*, and show how to solve it on multiple processors. \n",
    "\n",
    "\n",
    ">### <font color='green'>Track 2 </font> \n",
    "<font color='green'>As another example of a similar spatially extended cellular automaton, notice that the probability distribution of having a certain number of molecules in the Chemical Master Equation (CME), which we studied in Track 2 in the previous module, depends on that number of molecules as well as on time, $P=P(n,t)$. So while the CME does not describe a function $P(n,t)$ for a continuous $n$, it becomes very similar to the discretized dynamics of continuous fields, such as $T$ above, when both are represented on a digital computer. The dimensionality of the dynamics of the CME thus scales as $N\\sim \\prod N_{{\\rm max},i}\\sim N_{\\rm max}^d$, where $N_{{\\rm max},i}$ is the maximum allowable number of molecules of a chemical species $i$ involved in the process, and $d$ is the dimensionality, or the number of these species. Thus if the number of chemical species involved in the dynamics is more than a few (and it can be arbitrary large!), the CME becomes a system of astronomically many coupled ODEs, and parallelizing the code becomes even more important than for fields in real spatial dimensions.</font>  \n",
    "\n",
    "\n",
    "### Newton's law of cooling and Fourier's law of heat conductance\n",
    "Let's start with a simple example. Suppose you have two bodies in contact with temperatures $T_1$ and $T_2$. How do their temperatures depend on time? To develop a mathematical model of this process, we note that the heat flow is directional: heat flows from the high temperature body to the low temperature one. This means that the heat transfer should be proportional to the odd power of the temperature difference. The simplest such relation (which is also supported experimentally) is that the rate of heat transfer is *proportional to the difference in temperatures between the two bodies*. In other words, \n",
    "$$\\frac{ dQ_{1\\to2}}{dt} = \\kappa (T_1-T_2),$$\n",
    "where $\\Delta Q_{1\\to2}$ is the heat that went from body 1 to body 2, $T_i$ are their respective temperatures, and $\\kappa$ is some coefficient of proprtionality, which will depend on the material the bodies are made from, the shape of the bodies, their contact area, and so on. Notice that the sign here is such that the heat, indeed, goes from the hot body to the cold one. We can extend this a bit by noticing that the temperature of a body and the total amount of heat in it are proportional to each other -- the more heat there is, the higher the temperature:   \n",
    "$$Q_i=C_iT_i.$$\n",
    "Here the coefficient of proportionality is known as the <font color='red'>**heat capacity**</font>. In other words, for example, $dT_1=- C_1dQ_{1\\to2}=C_1dQ_{2\\to1}$. Combining with the previous equation, we get:\n",
    "$$\\frac{ dT_{1}}{dt} = k (T_2-T_1),$$\n",
    "where $k$ now combines both $\\kappa$ and $C_1$. \n",
    "\n",
    "<font color='pink'>**ToDo:** add picture of temperature as 1-d field</font> \n",
    "Now consider a situation where $T$ is, in fact, a field $T(x,t)$, so that what we called $T_1$ and $T_2$ are instead $T(x)$ and $T(x+dx)$, and $T_2-T_1\\to dT(x)$. In the $dQ_{1\\to2}$ equation above, $\\kappa(T_2-T_1)$ is then replaced with $k\\frac{\\partial T}{\\partial x}$. (For those of you not familiar with multivariate calculus, the expression $\\partial T$ stands for a difference in $T$ only due to changes in space, while considering time constant.) As a result, if we define $j(x)=\\frac{dQ(x)}{dt}$ -- <font color='red'>**the heat flux**</font> -- we get:\n",
    "$$j= - k\\frac{\\partial T}{\\partial x},$$\n",
    "where the minus sign signifies, as always, that the flux goes from the hot to the cold area.\n",
    "\n",
    ">### <font color='green'>Track 2: Higher dimensions</font>\n",
    "<font color='green'>Those of you who have taken multivariate calculus, will easily derive that, in more than one spatial dimension, the equation for the heat flux transforms into:\n",
    "   $$\\vec{j}= - k\\nabla T.$$\n",
    "</font>\n",
    "\n",
    "All of the equations above describe basically just one phenomenon: the heat flows from a hot body to a cold one in proportion to the temperature difference. The equations just describe slightly different forms of this law: are we are talking above differential changes of temperature over space, or differences between finite bodies? Are we considering changes in temperature vs. heat? Depending on these details, this one law then is known as either the *Newton's law of cooling* or the *Fourier's law of heat conductance.*\n",
    "\n",
    "Interestingly, if we are considering exchange of particles between two reservoirs through diffusion, so that the concentration is measured by the particle density $\\rho_1$ and $\\rho_2$ (or, for a continuous case, $\\rho(x)$), then the particles diffuse from the area where there are more of them to the area, where there are fewer. As a result, we can repeat the same arguments and arrive to the law of particle flux due to diffusion:\n",
    "$$j= - D\\frac{\\partial \\rho}{\\partial x}.$$\n",
    "This is known as the *Fick's first law of diffusion*, and the coefficent $D$ is the diffusion constant (the same diffusion constant we introduced for random walks in the previous module). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Partial Differential Equations (PDEs): The diffusion equation cellular automaton\n",
    "In the examples above, we only considered the dynamics of the temperature for two bodies exchanging heat. Now let's consider an extended body in one dimension, which we will discretize in small elements of length $\\Delta x$, and the temperature becomes then $T(i\\Delta x,t)=T_i(t)$. If we want to understand the dynamics of $T(i\\Delta x,t)$, we need to consider two heat fluxes: between points $i-1$ and $i$, and between points $i$ and $i+1$. Then the total change of heat at the point $i$ is:\n",
    "$$\\frac{dQ_i}{dt}=-\\frac{\\kappa}{\\Delta x} [T_i(t)-T_{i-1}(t)] + \\frac{\\kappa}{\\Delta x}  [T_{i+1}(t)-T_{i}(t)]= \\frac{\\kappa}{\\Delta x}  [ T_{i+1}(t)+T_{i-1}(t) - 2 T_i(t)].$$\n",
    "Notice that I carry aound the weird coefficient $\\frac{\\kappa}{\\Delta x}$. This is because, in this case, $T_i-T_{i-1}$ and $T_{i+1}-T_{i}$ are both *infinitesimal* (since we are looking at temperature changes over very small distances), and the weird factor of $1/\\Delta x$ is needed to compensate for this.  \n",
    "\n",
    "Now, as always, the heat flux will change the temperature $(C\\Delta x)dT= dQ$, where $C\\Delta x$ is the heat capacity of the small segment of the material of length $\\Delta x$, and $C$ is then the **<font color='red'>specific heat capacity</font>** (again, notice that we have to be careful with the factors of $dx$). With this definition, we get equation for the dynamics of the temperature at a specific point \n",
    "$$\\frac{dT(x,t)}{dt}=k \\frac{ T(x-\\Delta x,t)+T(x+\\Delta x,t) - 2 T(x,t)}{\\Delta x^2}.$$\n",
    "This is a discretized form of the following partial differetial equation:\n",
    "$$\\frac{dT(x,t)}{dt}=k \\frac{\\partial^2 T}{\\partial x^2}.$$\n",
    "\n",
    "If we have a two-dimensional system, so that $T=T(x,y,t)$, and if we choose $\\Delta x=\\Delta y$, then this easily generalizes to:\n",
    "$$\\frac{dT(x,y,t)}{dt}=k \\frac{T(x-\\Delta x,y,t)+T(x+\\Delta x,y, t) + T(x,y-\\Delta x,t) + T(x,y+\\Delta y,t) - 4 T(x,t)}{\\Delta x^2}.$$\n",
    "What we wrote above is the discretized version of the heat diffusion equation. Replacing $T$ with $\\rho$ and $k$ with $D$, this is also a discretized version of the diffusion equation, also known as the Fick's second law of diffusion. \n",
    ">### Your turn 6.2:\n",
    "Derive the two-dimensional and the three-dimensional heat diffusion equation.\n",
    "\n",
    ">### <font color='green'>Track 2: Higher dimensions</font>\n",
    "<font color='green'>Those of you who have taken multivariate calculus, will easily derive that, in more than one spatial dimension, the heat diffusion equation becomes \n",
    "    $$\\frac{dT(x,t)}{dt}=k \\nabla^2 T.$$\n",
    " </font>\n",
    " \n",
    "The discretized version of the diffusion equation is very suggestive: it is a set of coupled ODEs, one ODE for each spatial point on a lattice $(x,y)$, and the dynamics of temporature at every point depends on the current temperature at neighbors. We can solve this using the standard forward Euler algorithm for a system of ODEs. That is, in two dimensions, with $\\Delta x=\\Delta y$:\n",
    "$$\\begin{align}\n",
    "T(i\\Delta x, j\\Delta x, t+\\Delta t) =& T(i\\Delta x, j\\Delta y, t) \\\\&+ k\\Delta t  \\frac{ T((i-1)\\Delta x, j\\Delta x, t)+T((i+1)\\Delta x, j\\Delta x, t) + T(i\\Delta x, (j-1)\\Delta x, t)  + T(i\\Delta x, (j+1)\\Delta x, t)- 4 T(i\\Delta x,j\\Delta x, t)}{\\Delta x^2}.\\end{align}$$\n",
    "The (deterministic) cellular automaton form of this solution is now clear: the state of every cell (aka, lattice point) is its temperature value. The state changes in an interaction with all nearby cells, and the cycle repeats.\n",
    "\n",
    "The rule by which the temperature changes is interesting. First, we subtract the current local temperature at a point from the average value of all nearby temperatures. If the local temperature is higher than the average, then the change in the local temperature is negative (the heat flows away from the point). If the local temperature is  lower than the average, then the heat flows toward the center, and the temperature increases. Thus the steady state of the diffusion equation (reminder: the steady state is achieved when the state variables of the system -- here $T$ -- stop changing with time) is achieved when every temperature in the tracked volume is equal to the average temperature around it. This only happens in the thermal equilibrium. In particular, when we start with the temperature on the boundary of the body being constant, then the equilibrium is when *all* temperatures in the volume are constant. This agrees with our intuition -- temperature in a body that has a constant temperature $T$ on its surface equilibrates to the same value as on the surface.\n",
    "\n",
    "A few key technical comments about the discretized heat diffusion equation are in order. First, in solving the equation solution, we *should* use $\\Delta x=\\Delta y$, and we *should* use the Euler scheme, but *not* more complicated Runge-Kutta or similar schemes. This is because the diffusion equation exhibits **<font color='red'>instabilities</font>**: everpresent small numerical truncation errors generally grow exponentially, and make a solution incorrect beyond a few $\\Delta t$'s. Only specific numerical algorithms result in cancellation of these instabilities and in relatively accurate solutions. Luckily, the forward Euler scheme is one of those! While a detailed discussion of instabilities in PDEs is beyond the scope of this class, you should remember that instabilitiles exist, and are a problem in complex spatially extended simulations, so that not every agorithm translates easily from the ODE context to the PDE one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boundary and initial conditions\n",
    "The heat diffusion equation in the Euler finite difference cellular automaton form takes the current value of the discretized field of temperatures and calculates the values of the temperature one step forward in time from them. Thus we need to have the initial condition specified: $T(x,y,t=0)=T_0(x,y)$ must be given, as for any set of ODEs. Then for any point that is inside the range, in which we are evolving the temeprature, will be able to calculate the future value of the temperature from its current value. But we cannot do this for the boundary of the range -- evolution forward in time requires calculation of the average temperature around a point, and we need to define what we mean by *around* for any point on the boundary. Specification of what happens on the boundary is known as the <font color='red'>boundary condition</font>. There are three types of boundary conditions that we use routinely in the diffusion equation and many other PDE-related problems. We will consider them one at a time.\n",
    "\n",
    "#### Absorbing boundary conditions\n",
    "Imagine that the boundary is kept externally at a fixed temperature. Physically, this can mean that the body is in contact with a heat source or sink. Then any heat that arrives to the boundary in excess to what is needed to keep it at the boundary temperature will get absorbed, given rise to what we call the <font color='red'>**absorbing boundary conditions**</font>. Computationally, this is easy to implement. In two dimensions, suppose we have lattice $x=i\\Delta x, y=j\\Delta x$, where $i=1\\dots L_x$, and $j=1\\dots L_y$ (extensions to other dimensions are easy). Then we can extend the lattice by creating a rim around it, $i=0$ (left rim), $j=0$ (bottom rim), $i=L_x+1$ (right rim), and $j=L_y+1$ (top rim). We can keep the temperature at the rim to be whatever is specified by the boundary conditions, and then every point inside the lattice has its four neighbors! So we can evaluate the next state of every point inside the range using the Euler diffusion cellualr automaton, and the boundaries go along for the ride. With initial conditions specified, this is all we need to solve the problem. It's also clear how to verify if absorbing boundary conditions were set up well: if we run the simulation till the steady state, the temperature of the entire object should settle to the temperature of the boundary (if the latter is constant everywhere).\n",
    "\n",
    "#### Reflecting boundary conditions\n",
    "Suppose the object, in which we are measuring the temperature relaxation is surround by a very good thermal insulator. Then the heat cannot escape the object, and no new heat can enter. How do we model this? Let's again extend the lattice with a one-cell rim around it. And let's at every time step set the temperature value at the rim equal to the first cell in the body: $T(0,y,t)=T(1,y,t)$, $T(L_x+1,y,t)=T(L_x,y,t)$, $T(x,0,t)=T(x,1,t)$, $T(x,L_y+1,t)=T(x,L_y,t)$. Now we can update the interior of the body at every time step, since the interior has all four neighbors. At the sam time, since the temperature at the boundary is the same as at the first interior point, there's no flux towards or from the boundary, and the heat won't be lost. That is, the heat coming to the boundary gets reflected back into the body, and hence the name: **<font color='red'>reflecting boundary conditions</font>**. This also suggest a verification for whether the reflecting boundary condition is set up correctly: all throughout the dynamics, the total heat (sum of all temperatures) in the body should not change with time. \n",
    "\n",
    "#### Periodic boundary conditions\n",
    "This is a bit of a theorist's idealization and not physical, but sometimes we need a system that is totally translationally symmetric, so that every point in it is as good as any other point. We can achieve this, again, by adding a rim around the lattice, and now setting at every time step: $T(0,y,t)=T(L_x,y,t)$, $T(L_x+1,y,t)=T(0,y,t)$, $T(x,0,t)=T(x,L_y,t)$, $T(x,L_y+1,t)=T(x,0,t)$ -- that is, the 0'th point on the lattice becomes equal to the $L$th, and the $L+1$st to the first. The lattice becomes periodic -- all the heat that escapes at the left reemerges on the right (and vice versa), and all the heat that escapes at the bottom reemerges from the top (and vice versa) -- hence the name **<font color='red'>periodic boundary condition</font>**. The periodicity also suggests a simple check for correctness -- the value of the temperature should be continuous across the boundary and into the other side of the lattice. And, similarly, to the reflecting condition, the total amount of heat the system must not change with time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solving the Diffusion Equation using Python\n",
    "The next Python code cells define all the functions needed to solve the the diffusion equation on a lattice. We start first with the customary initialization and import of all the necessary nmodules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialization block\n",
    "import numpy as np\n",
    "import time\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The solution itself will consist of a few steps. First, we define the function `diffusion()`, which implements the single step of the Euler finite difference cellular automaton for solving the diffusion equation. Second, we define the function `reflecting()`, which implements the reflecting bondary condition (you will have to define functions for other boundary conditions). Third, we define the function `sequential()`, which solves the diffusion equation by taking a lattice, calling a chosen boundary condition function, then calling the `diffusion()` function to perform one time step, and then repeating the boundary condition/time step for as long as needed. Finally, the main program initializes all of the parameters, calls the sequential solver, and prints the output.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# One step of the diffusion cellular automaton\n",
    "def diffusion(D, dx, dt, u):\n",
    "    \"\"\" \n",
    "    Compute one forward step in the temporal evolution of the diffusion equation using the\n",
    "    the forward Euler discretization scheme.\n",
    "    Usage: \n",
    "      u_next = diffusion(D, dx, dt, u)\n",
    "\n",
    "    Arguments:\n",
    "        D: diffusion constant\n",
    "        dt: step size in time\n",
    "        dx: step size in space\n",
    "        u: concentration on lattice points of diffusing quantity, assumed (Lx+2)*(Ly+2) because of the\n",
    "           boundary conditions\n",
    "    \n",
    "    Return: \n",
    "        u_next: u at the next time step\n",
    "        \n",
    "    Note that we assume that the lattice is enlarged with the boundary rim in all directions, \n",
    "    and the rim is used to implement the boundary conditions. Thus the actual lattice is Lx*Ly, \n",
    "    and we only need to propagate these internal points forward in time. \n",
    "    \"\"\"\n",
    "    Lx = u.shape[0] - 2 # Lx of the grid\n",
    "    Ly = u.shape[1] - 2 # Ly of the grid\n",
    "    \n",
    "    u_next = u[1:Lx+1,1:Ly+1] + (dt*D/dx**2)* ( -4*u[1:Lx+1,1:Ly+1] + u[0:Lx,1:Ly+1] +\n",
    "                                    + u[2:Lx+2,1:Ly+1] + u[1:Lx+1,0:Ly] + u[1:Lx+1,2:Lx+2] )\n",
    "\n",
    "    # we return the interior of the lattice Lx*Ly at the next time point\n",
    "    return u_next\n",
    "\n",
    "\n",
    "# Reflecting boundary condition\n",
    "def reflecting(u):\n",
    "    \"\"\" \n",
    "    Sets up reflecting boundary conditions. For this, the lattice, on which the diffusion equation is solved,\n",
    "    is extended by 1 in all directions, and the boundary columns and rows are duplicated (see lecture notes\n",
    "    for a detailed explanation).\n",
    "    \n",
    "    Usage: \n",
    "        u_bnd = reflecting(u)\n",
    "      \n",
    "    Arguments:\n",
    "        u: concentration on lattice points of diffusing quantity, assumed (Lx)*(Ly) \n",
    "    \n",
    "    Return: \n",
    "        u_bnd: u with the boundary rim with reflecting conditions set, size (Lx+2)*(Ly+2)\n",
    "    \"\"\"\n",
    "    Lx = u.shape[0]  # Lx of the grid\n",
    "    Ly = u.shape[1]  # Ly of the grid\n",
    "\n",
    "    u_bnd = np.zeros((Lx+2,Ly+2))  # setting up the extended grid\n",
    "    u_bnd[1:Lx+1,1:Ly+1] = u       # copying the bulk of the grid\n",
    "    u_bnd[0, 1:Ly+1] = u[0, :]     # setting the top boundary - by copying the top row\n",
    "    u_bnd[Lx+1, 1:Ly+1] = u[-1, :] # setting the bottom boundary - by copying the bottom row\n",
    "    u_bnd[1:Lx+1, 0] = u[:, 0]     # setting the left boundary - by copying the left column\n",
    "    u_bnd[1:Lx+1, Ly+1] = u[:, -1] # setting the right boundary - by copying the right colimn\n",
    "    \n",
    "    # now return the extended matrix\n",
    "    return u_bnd\n",
    "\n",
    "\n",
    "# sequential solution of the diffusion equation\n",
    "def sequential(initial, D, T, dx, dt, boundary):\n",
    "    ''' \n",
    "    Sequential processing solution of the diffusion equation in the forward Euler form.\n",
    "    Usage: \n",
    "        grid = sequential(initial, D, T, dx, dt, boundary)\n",
    "      \n",
    "    Arguments:\n",
    "        initial: rectangular lattice of initial heat distribution on the lattice\n",
    "        D: diffusion constant\n",
    "        T: time, for which we solve the problem\n",
    "        dx: lattice spacing (assumed the same in x and y direction)\n",
    "        dt: time step\n",
    "        boundary: function that expands the lattice by 1 in each direction and sets up \n",
    "            the boundary conditions\n",
    "      \n",
    "    Return:\n",
    "        grid: lattice the size of initial with the solution of the diffusion equation after time T\n",
    "    '''\n",
    "    \n",
    "    grid = initial   # setting up the initial condition\n",
    "    \n",
    "    # loop over solution time\n",
    "    for t in np.arange(int(T/dt)):\n",
    "        # apply the boundary condition\n",
    "        grid_bnd = boundary(grid) \n",
    "        # one step forward in the Euler solution\n",
    "        grid = diffusion (D, dx, dt, grid_bnd)\n",
    "        if (np.round(t/100)==t/100):\n",
    "            print('Solving time step t = '  + str(t) +'.')\n",
    "                \n",
    "                       \n",
    "    return grid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we made a lot of semi-arbitrary choices above, some good, and some questionable. For example, the `reflecting()` boundary condition function creates a new array with a rim around the old one, rather than returning the old array, just slices differently. This is clearly slower, because we need to copy numbers in this array. On the other hand, this makes it similar to how we would implement other boundary conditions. Specifically, while periodic conditions again can be done with slicing, for the absorbing conditions, there is no way of just slicing the array. Indeed, the conditions are set *externally*, and so the only way to program this would be either to have the lattice copied, or the conditions passes to the `diffusion()` function as additional arguments. The latter would mean that we have to write multiple different diffusion functions, and i don't like this. The former would mean that somtimes the boundary coundition function returns a new array, and sometimes a slice of the old array. And this may become confusing, and the inconsistency is dangerous -- remember that if, by mistake, we were to modify a variable pointing to a slice, we would modify the original array as well!  \n",
    "\n",
    "Additional choice i made above it to have the function `sequential()` to take, as an argument, a name of the function that sets up the boundary conditions. This is potentially a problem as well, since the reflecting or the periodic conditions do not require any more information, while to set up the absorbing conditions, one would require a value of the temperature, at which the boundary is kept. This value, presumably, would need to be passed as an argument to the `absorbing()` function if we were to write it, but the code above is not set for this. Additionally, it may be that the absorbing condition has a temprature on the boundary that is position-dependent, $T=T(x,y)$. This would mean that not just one value, but an array of boundary temperatures would need to be passed to the function. There are many choices to make, and sometimes the choices are not obvious (And we may need to revisit them when we talk about multiprocessing). Crucially, you will need to think about these choices when you work on one of the exercises below.\n",
    "\n",
    "Finally, we can write the main program that implements the sequential solution of the diffusion equation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solving time step t = 0.\n",
      "Solving time step t = 100.\n",
      "Solving time step t = 200.\n",
      "Solving time step t = 300.\n",
      "Solving time step t = 400.\n",
      "Solving time step t = 500.\n",
      "Solving time step t = 600.\n",
      "Solving time step t = 700.\n",
      "Solving time step t = 800.\n",
      "Solving time step t = 900.\n",
      "Sequential processing took 19.095986127853394s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initialization:\n",
    "\n",
    "dx = 0.5 # the lattice spacing; we will use the same lattice spacing in x and y directions, in meters\n",
    "dt = 0.1 # time step, sec\n",
    "L = 500  # system shape is square for convenience, in meters\n",
    "T = 100  # integration time, sec\n",
    "D = 0.5  # diffusion constant, in m/s^2\n",
    "\n",
    "# initial heat distribution\n",
    "grid_init = np.zeros((int(L/dx),int(L/dx))) \n",
    "gridsize = grid_init.shape\n",
    "grid_init[int(gridsize[0] / 2), int(gridsize[1] / 2)] = 70   # put a point source in the center, with intensity 70\n",
    "grid_init[int(gridsize[0] / 4), int(gridsize[1] / 4)] = 35   # put a point source at a quarter corner, intensity 35\n",
    "\n",
    "# solving the problem\n",
    "ts = time.time()  # measure computation time\n",
    "grid_end = sequential (grid_init, D, T, dx, dt, reflecting)\n",
    "print('Sequential processing took {}s'.format(time.time() - ts))\n",
    "\n",
    "# now doing the plotting\n",
    "fig, ax = plt.subplots(figsize=(5, 5), dpi= 120, facecolor='w', edgecolor='k')\n",
    "plt.imshow(grid_init, cmap=plt.cm.copper, extent=[-1,1,-1,1]);\n",
    "plt.xticks([]); \n",
    "plt.yticks([]);\n",
    "plt.title('Original heat distribution, maximum temperature: {}'.format(np.max(grid_init)))\n",
    "plt.show()\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(5, 5), dpi= 120, facecolor='w', edgecolor='k')\n",
    "plt.imshow(grid_end, cmap=plt.cm.copper, extent=[-1,1,-1,1]);\n",
    "plt.xticks([]); \n",
    "plt.yticks([]);\n",
    "plt.title('Final heat distribution, maximum temperature: {}'.format(np.max(grid_end)))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">### Your turn 6.3\n",
    "Time the solution of the diffusion equation for different $L$ at fixed $\\Delta x$. How do you expect the complexity of the problem to grown with $L$? How does it grow with $L$?\n",
    "\n",
    ">### Your turn 6.4\n",
    "Write functions to implement absorbing and periodic boundary conditions. While the periodic conditions are simple, the absorbing conditions may require more work (see the discussion in the text) because they need an argument for the value of the temperature at the boundary. There are multiple ways of implementing this. First, you may have the temperature at the boundary (either a single constant, or the entire $T(x,y)$ on the boundary rim) as a global variable, and then your `absorbing()` function would use it. Second, you may change the `sequential()` function in a way to allow for a variable number of arguments, one of which -- if it is set --  could be the boundary temperate, and then to pass this variable set of arguments to the function encoded in the argument `boundary`, which can now be your `absorbing()` function. Third you can discard usage of separate `absorbing()`, `reflecting()`, or `periodic()` functions, and instead write a single `boundary_rim()` function, which woud take as the arguments the lattice and the four boundary arrays (left, right, top, bottom), and then different boundary conditions would be implemented inside the `sequential()` function, which would pass different boundary arrays as arguments to the `boundary_rim()`. Or you can try something totally different. It's your choice. When the program is working, explore how the heat diffuses in this system. For this you may need to decrease $L$ and increase $T$ (keep other parameters stationary for now). Verify your boundary condition functions as discussed in the lecture notes.\n",
    "\n",
    ">### Your turn 6.5\n",
    "The Euler finite difference scheme for solving the diffusion equation has a well-known instability, called the *von Neumann* instability. When $r=\\frac{D\\Delta t}{\\Delta x^2}>1/2$, the numerical solution behaves erratically, starts oscillating spatially and temproally, and eventually diverges. This critical value is correct for an infinite size system, and problems may emerge even earlier when the system size is smaller. For the parameters in the code above, we have  $r=\\frac{D\\Delta t}{\\Delta x^2} =\\frac{0.5\\times 0.1}{.5^2} = 0.2<0.5$. Thus the solution should be stable (and it is). Change $D,\\Delta x, \\Delta t$ and observe what happens when you transition from $r=0.2$ to $r=0.6$. Then explore other more extremevalues of $r$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiprocessing module\n",
    "It is crucial that you read the documentation for this module and understand it well https://docs.python.org/2/library/multiprocessing.html. This is quite probably the most complicated Python concept that we have studied to date, and this notebook cannot do it justice.\n",
    "\n",
    "First let's load the multiprocessing module, and explore which functions it provides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Array',\n",
       " 'AuthenticationError',\n",
       " 'Barrier',\n",
       " 'BoundedSemaphore',\n",
       " 'BufferTooShort',\n",
       " 'Condition',\n",
       " 'Event',\n",
       " 'JoinableQueue',\n",
       " 'Lock',\n",
       " 'Manager',\n",
       " 'Pipe',\n",
       " 'Pool',\n",
       " 'Process',\n",
       " 'ProcessError',\n",
       " 'Queue',\n",
       " 'RLock',\n",
       " 'RawArray',\n",
       " 'RawValue',\n",
       " 'SUBDEBUG',\n",
       " 'SUBWARNING',\n",
       " 'Semaphore',\n",
       " 'SimpleQueue',\n",
       " 'TimeoutError',\n",
       " 'Value',\n",
       " '__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__path__',\n",
       " '__spec__',\n",
       " 'active_children',\n",
       " 'allow_connection_pickling',\n",
       " 'context',\n",
       " 'cpu_count',\n",
       " 'current_process',\n",
       " 'freeze_support',\n",
       " 'get_all_start_methods',\n",
       " 'get_context',\n",
       " 'get_logger',\n",
       " 'get_start_method',\n",
       " 'log_to_stderr',\n",
       " 'process',\n",
       " 'reducer',\n",
       " 'reduction',\n",
       " 'set_executable',\n",
       " 'set_forkserver_preload',\n",
       " 'set_start_method',\n",
       " 'sys']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import multiprocessing as mp\n",
    "dir(mp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `mp.cpu_count()` returns the number of available CPUs on the computer. This is the number of *logical* CPUs -- and usually, when we design our concurrent processing program, we should set the number of workers working in parallel to be equal to this number: any fewer or any more than that will likely result in a slower execution. In the former case, we will not be using all of the resources of the computer, since some of the processors will be waiting unused. In the second, we will be spending too much time on communication among the workers. \n",
    "\n",
    "This is how many processors I have on my machine: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of processors = 4.\n"
     ]
    }
   ],
   "source": [
    "print('Number of processors = ' +str(mp.cpu_count()) +'.') # this counts logical cpus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">### Your turn 6.6\n",
    "How many logical processors does your computer have?\n",
    "\n",
    "Now we can do our first program that would utilize multiple processors for concurrent processing. We will do summation of a set of numbers. I deliberately make the summation very inefficient: we are going to execute a `for` loop over the array, which is slow. However, increasing the complexity of the task by making it less efficient will make it easier to elucidate more clearly the advantage of concurrent processing. \n",
    "\n",
    "We will use the function `mp.Pool()` and the associated support functions to perform this concurrent task. First, `Pool()` creates a *pool* (a set) of workers -- subprograms (subprocess) that are available to execute the task concurrently. The main program then becomes the root -- the captain in our example above, who doesn't do any computation itself, but rather distributes the subtasks among the workers, ensures communication, and collects the results. `Pool` implements a *data partitioning* scheme of multiprocessing. Even more specifically, it implements data partitioning in such a way that every worker does the same computation (executes the same functions) on every subset of the data available. This is achieved by the method `map()` that every pool of workers has -- the method takes the same function and applies it to a list of data objectes, so that each worker applies the same function to one element in the list. The creation of the list is the job of the root program, as well as assembly of the results of these workers' work. Let's see how this works now.\n",
    "\n",
    "The cells below illustrate a simple example of multiplrocessing. We will sum a large array of numbers. First we will do it sequentially, and then concurrently with multiple workers, and compare results. For the concurrent processing, we must first take the array of numbers and to transform it into a a list of subarrays, and then the function `map()` can take the pool of workers and apply each worker to each element of the list. Finally we need to sum the results of the list of these subsums."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential processing took 5.363890171051025s\n",
      "Parallel processing took 1.7803399562835693s\n",
      "Sum of numbers from 0 to 33554432: parallel processing - 562949936644096, sequential processing - 562949936644096.\n"
     ]
    }
   ],
   "source": [
    "# Initialization block\n",
    "import numpy as np\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "import multiprocessing as mp\n",
    "\n",
    "# summing integers\n",
    "def sumnums(nums):\n",
    "    '''\n",
    "    The function sums integers in an array.\n",
    "    Usage:\n",
    "      s = sumnums(nums)\n",
    "    \n",
    "    Arguments:\n",
    "      nums: array of integers\n",
    "      \n",
    "    Return:\n",
    "      s: sum of the array\n",
    "    \n",
    "    The function is deliberately written not efficiently (doing a for loop over the array), so that it \n",
    "    takes a longer time to execute, and the effect of multiprocessing is more pronounced.\n",
    "    '''\n",
    "    s = 0\n",
    "    for x in nums:\n",
    "        s += x\n",
    "    return s\n",
    "\n",
    "\n",
    "# sequential processing\n",
    "def sum_sequential():\n",
    "    '''\n",
    "    The function sums integers in an array sequentially.\n",
    "    Usage:\n",
    "      s = sum_sequential()\n",
    "    \n",
    "    Arguments: none\n",
    "      \n",
    "    Return:\n",
    "      s: sum of the array\n",
    "    '''\n",
    "    \n",
    "    ts = time.time()                    # measure computation time\n",
    "    s = sumnums(range(maxnum))          # sum maxnum integers, starting from zero\n",
    "    print('Sequential processing took {}s'.format(time.time() - ts))\n",
    "    \n",
    "    return s\n",
    "\n",
    "\n",
    "# parallel processing\n",
    "def sum_parallel():\n",
    "    '''\n",
    "    The function sums integers in an array concurrently.\n",
    "    Usage:\n",
    "      s = sum_parallel()\n",
    "    \n",
    "    Arguments: none\n",
    "      \n",
    "    Return:\n",
    "      s: sum of the array\n",
    "    '''\n",
    "    \n",
    "    # now on to parallel processing\n",
    "    if __name__=='__main__':  # see discussion of this in the text below    \n",
    "        n_w = 4               # how many workers to use?\n",
    "        ts = time.time()      # starting time\n",
    "        pool = mp.Pool(processes = n_w)        # create a pool of n_w workers\n",
    "        # make a list subarrays\n",
    "        # Python knowledge check: make sure that you understand the command below\n",
    "        # and that you understand what happens if maxnum is not divisible by n_w\n",
    "        numlist = [range(int(maxnum/n_w*i), int(maxnum/n_w*(i+1))) for i in range(n_w)]   \n",
    "        subsums = pool.map(sumnums, numlist)   # calculate sums of each subarray concurrently using map()\n",
    "        s  = sumnums(subsums)                  # now sum the subsums\n",
    "        print('Parallel processing took {}s'.format(time.time() - ts))\n",
    "    else:\n",
    "        s = 0\n",
    "        \n",
    "    return s\n",
    "\n",
    "# Main program\n",
    "\n",
    "# how many integers will we sum?\n",
    "maxnum = 2**25    \n",
    "\n",
    "s_s = sum_sequential()\n",
    "s_p = sum_parallel()\n",
    "\n",
    "print(\"Sum of numbers from 0 to %d: parallel processing - %d, sequential processing - %d.\" % (maxnum, s_p, s_s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">### Your turn 6.7\n",
    "Become familiar with the simple concurrent summation of numbers. Run the code with different values of `n_w`, including values that are not divisors of `maxnum`. Does the program handle this well? Plot the speedup due to the parallel execution time as a function of `n_w` (you may need to average the run times over a few equivalent runs, to avoid fluctuations due to unrelated work that your computer performs). What is the best value of `n_w` for speed? How does it compare with your number of CPUs?\n",
    "\n",
    ">### Your turn 6.8\n",
    "Explain why the speedup is never as high as the number of CPUs.\n",
    "\n",
    "\n",
    ">### Your turn 6.9\n",
    "What happens if the number of workers in the `pool` above is different from the number of elements in the `numlist`? Try this for yourself when the number of workers is too large or too small."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the check for the `__name__` in the code above. Specifically, what this does it to check whether the program is being executed by the main Python kernel, or whether we are trying to execute this within a child. Also note that I defined `sum_sequential()` and `sum_parallel()` functions, which we only use once from the main code. Why this complication? \n",
    "\n",
    "The answers are subtle. And both of them relate to how multiprocessing is implemented in a Unix based operating system (Mac or Linux) vs in Windows. On Unix machines, neither of these complications are required (though still useful), but they are essential on Windows machines. Here's why. \n",
    "\n",
    "Specifically, when you apply the `map()` function, what happens on a Mac or another Unix-based machine is that we create child processes. Each child processes will have access to all of the same data as the root process has. In fact, all of the data will be copied as many times as there are child processes, and each child will work on its own copy (this is one reason why having too many workers is not a good idea: copying takes time and memory). After this copying the children start execution -- and any of the modules that you imported in the main code, with all of their variables and data are available for each child. \n",
    "\n",
    "In contrast, multiprocessing on Windows is tricky. When `map()` creates child processes and gives control of the CPUs to them, Windows does not have a capacity to make all of the imported modules and their objects available to the children. So, in the Windows implementation of Python multiprocessing, data stuctures in the main program are not visible to the children, and each module previously imported by the main program will be reimported automatically by each child anew. In other words, objects created by the main program per se will not be accessible by the `Pool()` workers, but objects created in modules imported into the main program will be! That is, child processes and the main program behave very differently in Windows! Thus we need to think carefully which code we would like to allow to be executed only in the main program, and which code we can allow to be run by the child processes.\n",
    "\n",
    "In other words, if you want your multiprocessing code in Windows actually to be able to work, there are a few  things that must be done. First, most obviously, we do not want the code that creates child processes to run in child processes themselves, but only in the main program. Since any Python code may be encapsulated as a function or as a script, and be loaded and executed, it can be that some code that we write thinking that it is just part of a main program will them be executed from a child. We should avoid this -- and this is why we protect our code with  checking for `__name__ == '__main__'`, so that the rest of the code will only run from within the main program. Second, in Windows, since no data structures from the main program will be visible to the child processes, it is not trivial how to run multiprocessing and recreate those structures. One solution is to put your entire multiprocessing code (including definition of variables, functions that the `map()` method will appy to these variables, and so on) into a module. Then when you load a module in the main program, and execute `map()`, the child proceses will reimport the modules, re-create the data, and so on. \n",
    "\n",
    "Finally, even on a Mac or on Linux, we should be careful about which code can be executed in a child or the main program, and we should use `__name__ == '__main__'` or similar checks (Google how to check similarly if the code is being executed by a child). Indeed, suppose we create a giant array to work on. Subsets of the array will then be passed to child processes for whatever computation we want, and they will be copied for protection, so that children do not destroy the main copy, or each other's copies. At this point, creating a big array from scratch in a child is useless -- we should have done this only in the main program.\n",
    "\n",
    ">### Your turn 6.10\n",
    "If you are running Windows, the simple multiprocessing code above likely won't work. Move it into a loadable module, and it should now work. That is, create a module `multiprocessing_sum`. In that module, import `numpy`, `time`, `multiprocessing`, and any other modules you need. Move the definition of functions `sumnum()`, `sum_sequential()` and `sum_parallel()` into that module as well. Now in the main program load your own module, and run `sum_sequential()` and `sum_parallel()`. As explained above, when you now run the parallel processing version, each child process created by `Pool()` will have the modules reloaded automatically, and will thus be able to do perform the above execution. Do this even if you are working on a Mac, and make sure your code with a loadable module works as intended on your machine.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diffusion on multiple processors\n",
    "Now we understand enough about the multiprocessing on Python to be able to write down the multiprocessing version of the heat equation. We need to start with a few general comments. First, to utilize mutliple processors, we will need to partition the entire lattice on which we solve the heat diffusion into multiple sublattices. Maybe we want to do something like what's shown in the figure below. In the figure, as always, each color square represents a specific temperate in a single cell of a lattice, and the black circles on the periphery represent the boundary condition rim as explained above -- and these circles will need to be replaced by specific temperatures depending on which boundary conditions (periodic, absorbing, or reflecting) we use. We then divide the big lattice into four smaller sublattices. \n",
    "$$\\huge\n",
    "\\begin{array}{cccccc}\n",
    "&\\bullet&\\bullet&\\bullet&\\bullet\\\\\n",
    "\\bullet&\\color{darkred}{\\blacksquare}&\\color{red}{\\blacksquare}&\\color{#FF6E4A}{\\blacksquare}&\\color{#FF91A4}{\\blacksquare}&\\bullet\\\\\n",
    "\\bullet&\\color{navy}{\\blacksquare}&\\color{blue}{\\blacksquare}&\\color{skyblue}{\\blacksquare}&\\color{#00FFFF}{\\blacksquare}&\\bullet\\\\\n",
    "\\bullet&\\color{darkgreen}{\\blacksquare}&\\color{green}{\\blacksquare}&\\color{lightgreen}{\\blacksquare}&\\color{aquamarine}{\\blacksquare}&\\bullet\\\\\n",
    "\\bullet&\\color{brown}{\\blacksquare}&\\color{#C04000}{\\blacksquare}&\\color{orange}{\\blacksquare}&\\color{gold}{\\blacksquare}&\\bullet\\\\\n",
    "&\\bullet&\\bullet&\\bullet&\\bullet\\\\\n",
    "\\end{array} \n",
    "\\rightarrow \n",
    "\\begin{array}{ccc|ccc}\n",
    "&\\bullet&\\bullet&\\bullet&\\bullet\\\\\n",
    "\\bullet&\\color{darkred}{\\blacksquare}&\\color{red}{\\blacksquare}&\\color{#FF6E4A}{\\blacksquare}&\\color{#FF91A4}{\\blacksquare}&\\bullet\\\\\n",
    "\\bullet&\\color{navy}{\\blacksquare}&\\color{blue}{\\blacksquare}&\\color{skyblue}{\\blacksquare}&\\color{#00FFFF}{\\blacksquare}&\\bullet\\\\\n",
    "\\hline\n",
    "\\bullet&\\color{darkgreen}{\\blacksquare}&\\color{green}{\\blacksquare}&\\color{lightgreen}{\\blacksquare}&\\color{aquamarine}{\\blacksquare}&\\bullet\\\\\n",
    "\\bullet&\\color{brown}{\\blacksquare}&\\color{#C04000}{\\blacksquare}&\\color{orange}{\\blacksquare}&\\color{gold}{\\blacksquare}&\\bullet\\\\\n",
    "&\\bullet&\\bullet&\\bullet&\\bullet\\\\\n",
    "\\end{array} \n",
    "$$\n",
    "But this creates two problems -- each of the sublattices cannot be evolved forward independently over a long time by one worker in a pool anymore. First, in order to evolve the left-top subplattice, say, its bright blue element, we need to know what the neighbor temperatures are -- and the neighbors now reside in different sublattices! Second, the heat that flow out of one sublattice will have to flow into the other, and vice versa. Because of these two related problems, the workers have to talk to each other! And we are the ones who need to account for the communication among the workers in order to solve the problem. Usually it's figuring our how to do such communication is what will take the most of our effort when parallelizing the code. There is not a single good recipe for how to do this communication efficiently, and below I propose one particular scheme.\n",
    "\n",
    "First we notice that we can solve the problem of not kowing what to do with the bright blue cell (and other cells on the boundary) by adding the boundary rim around each sublattice, and then populating it with the temperatures from the appropriate cells in the nearby sublattices, as shown in the Figure.\n",
    "$$\\huge\n",
    "\\begin{array}{ccc|ccc}\n",
    "&\\bullet&\\bullet&\\bullet&\\bullet\\\\\n",
    "\\bullet&\\color{darkred}{\\blacksquare}&\\color{red}{\\blacksquare}&\\color{#FF6E4A}{\\blacksquare}&\\color{#FF91A4}{\\blacksquare}&\\bullet\\\\\n",
    "\\bullet&\\color{navy}{\\blacksquare}&\\color{blue}{\\blacksquare}&\\color{skyblue}{\\blacksquare}&\\color{#00FFFF}{\\blacksquare}&\\bullet\\\\\n",
    "\\hline\n",
    "\\bullet&\\color{darkgreen}{\\blacksquare}&\\color{green}{\\blacksquare}&\\color{lightgreen}{\\blacksquare}&\\color{aquamarine}{\\blacksquare}&\\bullet\\\\\n",
    "\\bullet&\\color{brown}{\\blacksquare}&\\color{#C04000}{\\blacksquare}&\\color{orange}{\\blacksquare}&\\color{gold}{\\blacksquare}&\\bullet\\\\\n",
    "&\\bullet&\\bullet&\\bullet&\\bullet\\\\\n",
    "\\end{array} \n",
    "\\rightarrow\n",
    "\\begin{array}{cccc|cccc}\n",
    "&\\bullet&\\bullet&&&\\bullet&\\bullet\\\\\n",
    "\\bullet&\\color{darkred}{\\blacksquare}&\\color{red}{\\blacksquare}&\\color{#FF6E4A}{\\bullet}&\\color{red}{\\bullet}&\\color{#FF6E4A}{\\blacksquare}&\\color{#FF91A4}{\\blacksquare}&\\bullet\\\\\n",
    "\\bullet&\\color{navy}{\\blacksquare}&\\color{blue}{\\blacksquare}&\\color{skyblue}{\\bullet}&\\color{blue}{\\bullet}&\\color{skyblue}{\\blacksquare}&\\color{#00FFFF}{\\blacksquare}&\\bullet\\\\\n",
    "&\\color{darkgreen}{\\bullet}&\\color{green}{\\bullet}&&&\\color{lightgreen}{\\bullet}&\\color{aquamarine}{\\bullet}\\\\\n",
    "\\hline\n",
    "&\\color{navy}{\\bullet}&\\color{blue}{\\bullet}&&&\\color{skyblue}{\\bullet}&\\color{#00FFFF}{\\bullet}\\\\\n",
    "\\bullet&\\color{darkgreen}{\\blacksquare}&\\color{green}{\\blacksquare}&\\color{lightgreen}{\\bullet}&\\color{green}{\\bullet}&\\color{lightgreen}{\\blacksquare}&\\color{aquamarine}{\\blacksquare}&\\bullet\\\\\n",
    "\\bullet&\\color{brown}{\\blacksquare}&\\color{#C04000}{\\blacksquare}&\\color{orange}{\\bullet}&\\color{#C04000}{\\bullet}&\\color{orange}{\\blacksquare}&\\color{gold}{\\blacksquare}&\\bullet\\\\\n",
    "&\\bullet&\\bullet&&&\\bullet&\\bullet\\\\\n",
    "\\end{array} \n",
    "$$\n",
    "Now we are able to move one time step forward in our forward Euler cellular automaton.  However, after the move one step forward, each of the temperatures in each sublattice will change, and so we cannot just evolve the sublattices independently. Instead, after every step  forward, we need to stop, and copy temeperatures from the nearby sublattices again. Thus the algorithm should look like: \n",
    "1. Set the boundary conditions for the whole lattice.\n",
    "2. Partition the lattice into as many sublattices as there are workers.\n",
    "3. Add internal boundary conditions for each sublattice by copying data from the neighboring lattices.\n",
    "4. Do one time step forward.\n",
    "5. Repeat starting with item (1) until we evolve the lattice to a required time.\n",
    "\n",
    "We already have implemented the step (4) from the above in the `diffusion()` function from concurrent processing, which can easily be used by each of the workers. However, we have not yet implemented a function that does (3). In principle, we can do this function concurrently, and only use multiple processors to do (4). However, inserting the rows and columns for the internal boundary conditions will be slow -- and might take as much time as actually solving the problem, and we should think about how to implement (3) on multiple cores as well. Below I provide a solution. We will write a new function called `boundaryMP()`, which will take on the input a matrix of bulk values, as well as four arrays that it will use as four boundary rims. It will then output the expanded matrix. We can then ask every worker first to create its own expanded matrix, and then to propagate it forward in time. Since most likely the bulk and the boundary rim arrays will be various slices of the big lattice, their assembly into data structure for later merging into the expanded sublattices will not involve any copying of data, and will likely be fast.  So let's try this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialization block\n",
    "import numpy as np\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "import multiprocessing as mp\n",
    "\n",
    "# boundary conditions for the multiprocessing solution\n",
    "def boundaryMP(data):\n",
    "    '''\n",
    "    The function takes a lattice and the four arrays of boundary values and merges them into\n",
    "    an extended lattice with a boundary rim\n",
    "    \n",
    "    Usage:\n",
    "      u_ext = boundaryMP(data)\n",
    "    \n",
    "    Arguments: \n",
    "      data: a list of the data that must be combined; data[0] is an Lx*Ly array of values of the\n",
    "         diffusing quantity on the lattice; data[1] is the top boundary condition, data[2] is the bottom\n",
    "         boundary condition; data[3] is the left boundary condition, and data[4] is the right condition\n",
    "      \n",
    "    Return:\n",
    "      u_ext: extended lattice with the boundary rim\n",
    "      \n",
    "    Note that the function does not check that the dimensions of different elements in data agree with \n",
    "    each other\n",
    "    '''\n",
    "\n",
    "    # unwrapping the data\n",
    "    (u, top, bottom, left, right) = data \n",
    "\n",
    "    (Lx, Ly) = u.shape           # dimensions of the data, rows (x) * columns (y)\n",
    "    u_ext = np.zeros((Lx+2,Ly+2)) # creating the extended lattice\n",
    "    \n",
    "    # merging data into the extended matrix\n",
    "    u_ext[1:-1,1:-1] = u\n",
    "    u_ext[0,1:-1]    = top\n",
    "    u_ext[-1,1:-1]   = bottom\n",
    "    u_ext[1:-1,0]    = left\n",
    "    u_ext[1:-1,-1]   = right\n",
    "    \n",
    "    return u_ext"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this function written down, now we can write the parallel solution of the diffusion equation with the reflecting boundary conditions, `parallel_relecting()`. Note that because we restructured how the boundary conditions are handled by introducing the `boundaryMP()` function, we now need to write separate parallel processing function for each initial condition, and the block that creates the boundary conditions will change inside each such function.\n",
    "\n",
    "There's just one thing remaining. Recall that `Pool.map(fulction,list)` applies the same function (its first argument) to each of the data objects in the list of data (its second argument). By construction, the `function` argument should have only one argument of its own -- namely, the data on which it will work. In our case, however, the `diffusion()` function takes many more arguments in addition to the lattice, on which it needs to work. We need to rewrite the function so that it is only a function of one argument! Luckily, Python offers yet another function to do just that! Namely, the function `partial()` from the module `functools` can freeze a partial list of arguments in any function to any constant value  its argument function. Notice that we need to do this freezing *inside* `parallel()`, so that every time `parallel()` is executed, these additional arguments of `diffusion()` are frozen at their current values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing the partial function\n",
    "from functools import partial\n",
    "\n",
    "# One step of the diffusion cellular automaton\n",
    "def parallel_reflecting(initial, D, T, dx, dt, units):\n",
    "    ''' \n",
    "    Parallel processing solution of the diffusion equation with reflecting boundary conditions \n",
    "    in the forward Euler form.\n",
    "    Usage: \n",
    "        grid = parallel_reflecting(initial, D, T, dx, dt, units)\n",
    "      \n",
    "    Arguments:\n",
    "        initial: rectangular lattice of initial heat distribution on the lattice\n",
    "        D: diffusion constant\n",
    "        T: time, for which we solve the problem\n",
    "        dx: lattice spacing (assumed the same in x and y direction)\n",
    "        dt: time step\n",
    "        units: number of workers to utilize\n",
    "             \n",
    "    Return:\n",
    "        grid: lattice the size of initial with the solution of the diffusion equation after time T\n",
    "    '''\n",
    "    \n",
    "    grid = initial   # setting up the initial condition\n",
    "    (Lx, Ly) = grid.shape\n",
    "    \n",
    "    # we require even number of workers in the pool, \n",
    "    # and we will partition Lx*Ly matrix into units/2 *2 sublattices\n",
    "    # define how many partitions of grid in x and y direction and their length\n",
    "    (nx, ny) = (int(units / 2), 2)\n",
    "    lx = int(Lx / nx)\n",
    "    ly = int(Ly / ny)\n",
    "    if(Lx*Ly != lx*ly*nx*ny):\n",
    "        error('Do not know how to partition the lattice this way.')\n",
    "\n",
    "    #creating the pool of processors\n",
    "    p = mp.Pool(nx*ny)\n",
    "\n",
    "    # this makes sure that D, dx, dt are the same when distributed over processes\n",
    "    # for integration, so the only interface parameter that changes is the grid\n",
    "    diffusionMP = partial(diffusion, D, dx, dt)    \n",
    "    \n",
    "    \n",
    "    # loop over solution time\n",
    "    for t in np.arange(int(T/dt)):\n",
    "        # we will first create boundary conditions for each sublattice using multiple workers\n",
    "        data = []                # creating an empty list of data for this\n",
    "        # looping over all sublattices\n",
    "        for i in range(nx):\n",
    "            for j in range(ny):\n",
    "                subgrid =  grid[i*lx : (i+1)*lx, j*ly : (j+1)* ly]\n",
    "                \n",
    "                if (i==0):        # this sublattice has top boundary condition that is reflecting\n",
    "                    top = subgrid[0,:]\n",
    "                else:             # get the bottom row from the higher subgrid as the boundary here\n",
    "                    top = grid[i*lx-1, j*ly : (j+1)* ly]\n",
    "                if (i==nx-1):     # this sublattice has bottom boundary condition that is reflecting\n",
    "                    bottom = subgrid[-1,:]\n",
    "                else:             # get the top row from the lower subgrid as the boundary here\n",
    "                    bottom = grid[(i+1)*lx, j*ly : (j+1)* ly]\n",
    "        \n",
    "                if (j==0):        # this sublattice has left boundary condition that is reflecting\n",
    "                    left = subgrid[:,0]\n",
    "                else:             # get the righmost row from the subgrid one to the left as the boundary here\n",
    "                    left = grid[i*lx : (i+1)*lx, j*ly-1]\n",
    "                if (j==ny-1):     # this sublattice has right boundary condition that is reflecting\n",
    "                    right = subgrid[:,-1]\n",
    "                else:             # get the leftmost row from the subgrid one to the right as the boundary here\n",
    "                    right = grid[i*lx : (i+1)*lx, (j+1)*ly]\n",
    "\n",
    "                # we now create a single data element from which the extended lattice will then be formed\n",
    "                # by pool.map \n",
    "                data_element = (subgrid, top, bottom, left, right)\n",
    "                # and finally we add this element to the data list\n",
    "                data.append(data_element)\n",
    "    \n",
    "        # at this point the boundary conditions data is prepared, and we need to\n",
    "        # combine these data into the extended grids, with individual workers working on\n",
    "        # individual grids and their boundaries\n",
    "        grids_ext = p.map(boundaryMP, data)\n",
    "  \n",
    "        # now we need to use the workers to advance the elements of the sublattices one time \n",
    "        # step forward in time\n",
    "        grids_next = p.map(diffusionMP, grids_ext)\n",
    "        \n",
    "        # now all of the sublattices returned by the workers must be combined\n",
    "        for i in range(nx):\n",
    "            for j in range(ny):\n",
    "                grid[i*lx : (i+1)*lx, j*ly : (j+1)* ly]  = grids_next[i*ny+j]\n",
    "        \n",
    "        if (np.round(t/100)==t/100):\n",
    "            print('Solving time step t = '  + str(t) +'.')\n",
    "                \n",
    "    return grid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now with the parallel processing version of the solver defined, we can run it and compare to the sequential solver. We will re-initialize various constants and re-run the sequential solver here just in case, to make sure that the parameters have not be re-defined above, and we are comparing apples to apples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solving time step t = 0.\n",
      "Sequential processing took 1.4668700695037842s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solving time step t = 0.\n",
      "Parallel processing took 20.889792919158936s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initialization:\n",
    "\n",
    "dx = 0.5 # the lattice spacing; we will use the same lattice spacing in x and y directions, in meters\n",
    "dt = 0.1 # time step, sec\n",
    "L = 500  # system shape is square for convenience, in meters\n",
    "T = 10  # integration time, sec\n",
    "D = 0.5  # diffusion constant, in m/s^2\n",
    "\n",
    "n_w = mp.cpu_count() # number of workers\n",
    "\n",
    "# initial heat distribution\n",
    "grid_init = np.zeros((int(L/dx),int(L/dx))) \n",
    "gridsize = grid_init.shape\n",
    "grid_init[int(gridsize[0] / 2), int(gridsize[1] / 2)] = 70   # put a point source in the center, with intensity 70\n",
    "grid_init[int(gridsize[0] / 4), int(gridsize[1] / 4)] = 35   # put a point source at a quarter corner, intensity 35\n",
    "\n",
    "# solving the problem sequentially \n",
    "ts = time.time()  # measure computation time\n",
    "grid_s = sequential (grid_init, D, T, dx, dt, reflecting)\n",
    "print('Sequential processing took {}s'.format(time.time() - ts))\n",
    "\n",
    "# now doing the plotting\n",
    "fig, ax = plt.subplots(figsize=(5, 5), dpi= 120, facecolor='w', edgecolor='k')\n",
    "plt.imshow(grid_init, cmap=plt.cm.copper, extent=[-1,1,-1,1]);\n",
    "plt.xticks([]); \n",
    "plt.yticks([]);\n",
    "plt.title('Original heat distribution, maximum temperature: {}'.format(np.max(grid_init)))\n",
    "plt.show()\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(5, 5), dpi= 120, facecolor='w', edgecolor='k')\n",
    "plt.imshow(grid_s, cmap=plt.cm.copper, extent=[-1,1,-1,1]);\n",
    "plt.xticks([]); \n",
    "plt.yticks([]);\n",
    "plt.title('Final heat distribution, maximum temperature: {}'.format(np.max(grid_s)))\n",
    "plt.show()\n",
    "\n",
    "# solving the problem cincurrently\n",
    "if __name__=='__main__':\n",
    "    tp = time.time()  # measure computation time\n",
    "    grid_p = parallel_reflecting(grid_init, D, T, dx, dt, n_w)\n",
    "    print('Parallel processing took {}s'.format(time.time() - tp))\n",
    "    fig, ax = plt.subplots(figsize=(5, 5), dpi= 120, facecolor='w', edgecolor='k')\n",
    "    plt.imshow(grid_p, cmap=plt.cm.copper, extent=[-1,1,-1,1]);\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    plt.title('Final heat distribution, maximum temperature: {}'.format(np.max(grid_p)))\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">### Your turn 6.11\n",
    "Parallel processing code above is substantially (>15 times) slower that the sequential processing. Why? Which parts of the Euler loop take the longest? Can you suggest improvements?\n",
    "\n",
    ">### Your turn 6.12\n",
    "Write and verify functions for solving the diffusion equation on many processors with periodic and absorbing boundary conditions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Projects\n",
    "\n",
    "The following three projects are available for this module. For each of these projects, you will need to develop a discretized space model of the process. You will then write code for sequential simulation of the system. Finally you will write code for simulation of the system using a pool of workers of an arbitrary size. In your report, you will need to output (besides the usual verification figures) the movies of the dynamics of the system, and a few snapshots of this dynamics for a more detailed analysis. After that, the final plot should be the time it took to solve the problem vs. the number of workers in the pool, for the number of workers going from 1 to 10 or so. What is the speedup that you observe for a different number of workers?\n",
    "\n",
    "> ### Project 1: Conway's Game of Life (just fun)\n",
    "Game of Life is a cellular automaton devised by John Conway, a mathematician, in 1970. The rules of the game are simple:\n",
    " - The game is played on a large (potentially infinite) orthogonal grid.\n",
    " - The game uses discrete time.\n",
    " - Each cell on a grid can be in two states: alive (1) or dead (0).\n",
    " - Every cell interacts with 8 of its neighbors to establish if it will be alive or dead at the next time step\n",
    " - The transition rules are\n",
    "    - Any live cell with fewer than two lives neighbors dies (life is cooperative).\n",
    "    - Any live cell with two or three live neighbors lives.\n",
    "    - Any live cell with more than three live neighbors dies (overpopulation).\n",
    "    - Any dead cell with exactly three live neighbors becomes alive (is reproduced into) .\n",
    "    - All other dead cells remain dead.\n",
    "\n",
    "> You can read more about the game in __[this Wikipedia article](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life)__. Develop a model of the Game on multiple processors (as described above), and simulate it on a large lattice (few hundred by few hundred cells). Start with random initial conditions and see which examples of \"living\" organisms you can generate. Classify them. Plot the time it takes to evolve the system for some fixed $T$ steps vs. the number of workers in the pool.  \n",
    "\n",
    "> ### Project 2: Reaction-diffusion in development (biophysics)\n",
    "A drosophila egg can be represented as an ellipsoid of rotation of about 500 um along the longest diameter, and half as long along the shortest. To start the development of a fertilized egg, a mother fly deposits a mRNA of a certain protein (bicoid) at the tip of the egg. The protein is translated from its mRNA (you should model this as a constant influx of bicoid molecules at the tip of the egg), and starts diffusing over the 3-d volume of the embryo with the diffusion coefficient of about 20 um$^2$/s (though there are complications, and the spread of the molecule is likely not purely diffusional). While the bicoid diffuses, it also degrades with the time scale of about 3 min (again, there are complications). As a result, a gradient of bicoid gets established, and, later in development, different parts of the embryo read out their position inside the embryo by measuring the bicoid concentrations next to them. Simulate the process of establishment of the bicoid gradient on multiple cores. For this, you will need to use not cubic, but ellipsoidal boundaries and set reflecting boundary conditions on them. Still work with a cubic lattice, but make the boundary conditions band elliptical (to the extent that you can on a square lattice). You will also need to supplement every diffusion step with a reaction step accounting for the decay of the bicoid. Produce a movie of the concentration field in the cross-section of the embryo. Graph the concentration along the major axis in steady state. Explore how this concentration depends on the diffusion constant and the decay time. How does the time to the steady state depend on the diffusion constant? Finally, plot the time it takes to evolve the system for some fixed $T$ steps vs. the number of workers in the pool.   \n",
    "\n",
    "> ### <font color=green>Track 2: Project 3: Repressilator (biochemical kinetics)</font>\n",
    "Recall <font color=green>Track 2: Master Equation and the dynamics of the probability distribution</font> section in Chapter 5, in which we studied how to model the dynamics of probability distributions of a number of molecules. Let's now study a slightly more complicated system of three interacting genes, $A,B,C$, arranged in a logical circle: gene $A$ suppresses $B$, $B$ suppresses $C$, and $C$ suppresses $A$. This is known as the *repressilator* circuit, which was __[developed in *E. coli* by Elowitz and Leibler](http://elowitz.caltech.edu/publications/Repressilator.pdf)__. The deterministic dynamics of this system is governed by the following equations. First, each of the three types of proteins are translated from messenger RNAs (mRNAs) $$\\frac{dp_i}{dt}=a m_i-b p_i,$$ where $i=(A,B,C)$, $a$ and $b$ are constant rates, and $p$ and $m$ are protein and mRNA concentrations, respectively. In their turn, the production of mRNA is affected by the proteins that repress them, $$\\frac{dm_i}{dt}=\\alpha_0+\\frac{\\alpha}{K^2+p_{i-1}^2}-\\beta m_i,$$ where $K,\\alpha,\\beta$ are constants, and protein species $A-1$ corresponds to $C$. This system is known to develop oscillations, where concentration of each of the proteins go up and down periodically. Write the master equation for this system following the approach we took in Chapter 5, and solve it on multiple cores (the lattice that you will have to build to represent the state of the system will be 6 dimensional: three proteins and three mRNAs). Find parameter values that make the system oscillate (feel free to use the original article by Elowitz and Leibler as an inspiration for parameter values). Show the graphs of the probability distribution $P(p_A)$ as a function of time. Finally, plot the time it takes to evolve the system for some fixed $T$ steps vs. the number of workers in the pool. \n",
    "\n",
    "> ### <font color=green>Track 2: Project 4: Belousov-Zhabotinsky reaction (chemical physics)</font>\n",
    "__[Belousov-Zhabotinsky reaction](https://en.wikipedia.org/wiki/Belousov–Zhabotinsky_reaction)__ is a classic example of a nonlinear chemical oscillator based on propagation of waves in excitable media. It's typically modeled as an __[oregonator](https://en.wikipedia.org/wiki/Oregonator)__, with three differential equations describing species X, Y, and Z. Another good introduction is in __[Scholarpedia](http://www.scholarpedia.org/article/Oregonator)__; focus especially on the scaled form in Eqs. (4,5,6)). Now imagine that all species diffuse with similar (but not the same) diffusion constants. Set up such simulations on a square grid in 2d -- you need to keep track of concentration of all three species on every grid point, and, in addition to diffusion, there will be mass-action reactions on every site. Solbe this system using multiple cores and explore various diffusion constants. Find the parameter range at which the system, started with random initial conditions, develops the beautiful spiral waves seen in the first link above? Produce a movie of these waves. Finally, plot the time it takes to evolve the system for some fixed $T$ steps vs. the number of workers in the pool. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}