# Transport Math

In this series of short lectures I cover the key points in mathematical techniques useful for solving transport problems (or indeed many problems in engineering). These are designed as a "reminder" tool, as the techniques would have been covered in your various math classes and text books. Math is easy to forget, however, and thus such a reminder is likely to be very useful, particularly when learning transport: if you've got the math down, the physics of transport is a lot easier to follow! While many topics are included, I've also left off some rather important areas such as systems of linear equations, optimization, and advanced techniques such as index notation (-very- useful in fluid mechanics, however this material is also covered elsewhere on the website). The primary focus is on the calculus of ordinary and partial differential equations, which is often the material students find most elusive.

Most of this material is drawn from the contents of your calculus and differential equations classes. Some is drawn from your Numerical and Statistical Analysis course, some from Transport I (e.g., scaling and self-similar solutions) and some we will be going over in Transport II (primarily separation of variables and Monte Carlo calculations). Thus, if any of this material isn't clear - don't forget to ask about it in class!

## Transport Math Notes

A PDF file of the notes is given here.

## Video Narrations

• ### 0 Introduction

In this short video I provide an introduction to the topics we will discuss.

• ### 1 Differentiation

In this video I talk about differentiation, including how to use differentiation by parts and chain rule differentiation for more complicated problems

• ### 2 Integration

The opposite of differentiation is integration. In this video I discuss some common integrals, methods for evaluating integrals via integration by parts, and multiple integrals for multidimensional problems.

• ### 3 The Taylor Series

A massively useful tool, the Taylor Series (particularly for the case when expanded around zero) is described. Application to linearization of a function (useful in simplifying differential equations), series representations, and derivation of high order finite difference representations are discussed.

• ### 4 First Order Linear ODEs

There aren't many guarantees in differential equations, but this class has an analytic solution you can simply write down - very useful as it appears in all sorts of problems! Application to interest calculations is discussed, as is the method where you can (occasionally) reduce a higer order ODE to a first order ODE and simply write down the solution.

• ### 5 Higher Order Linear ODEs

Higher order linear ODEs are discussed, where the solution is broken into the sum of particular and homogenous solutions. The techniques are demonstrated for the solution of the resonance equations.

• ### 6 Special High Order Linear ODEs

Most high order linear ODEs are difficult to solve, however two (which often appear in engineering problems) have a simple solution: Constant coefficient ODEs and Euler equations. These are actually very closely related, and their solutions are discussed.

• ### 7 Solving ODEs via Transformation

ODEs, and in particular non-linear ODEs, are often tricky to solve. Here we look at three approaches that sometimes work: inversion (for first order non-linear problems), formation of perfect differentials, and transformation of the independent variable. Examples of each are provided.

• ### 8 Dependent Variable Transformation

A further approach which sometimes works is transformation of the dependent variable - in this case turning a rather complicated ODE into a constant coefficient one where we can simply write down the answer.

• ### 9 Numerical Solutions

While exact solutions to ODEs are nice, getting numerical solutions is often just as useful - and can be much easier. I discuss how you can convert higher order ODEs into systems of first order ODEs which can be integrated using canned solvers. In addition, the issue of boundary conditions is addressed via the "shooting method" to determine unknown initial conditions. As an example, this approach is implemented for the Falkner-Skan problem in the short function fsmiss.m which can be run from the Matlab command line using the command fminsearch('fsmiss',1)

• ### 10 Runge-Kutta Integration

Usually you will find it convenient to use a canned solver, however sometimes it is more convenient to write your own code. Here we see where the Runge-Kutta integration method comes from and its limitations.

• ### 10a Numerical Example

In this lecture I discuss code which implements all the numerical solution techniques described above - the code is provided as well, which provides a useful template. The exampe code is numsolexample.m

• ### 11 Sturm-Liouville Theory

Many problems in engineering produce a Sturm-Liouville boundary value problem. Here I discuss the general theorem and apply it to a specific example. It will be used again later when discussing solution of differential equations via separation of variables.

• ### 12 PDEs: Div, Grad & Curl

We turn from ODEs to PDEs and discuss the key operators such as divergence, gradient, curl, laplacian, etc.. In addition the divergence theorem is introduced.

• ### 13 Solving PDEs via Simplification

PDEs are intrinsically harder to solve than ODEs. Here we discuss two methods for making your life easier: simplifying by making sure to use a coordinate system in which the boundary has a convenient representation, and simplification by allowing the boundary condition to suggest the form of the solution. Solving periodic problems via analytic continuation into the complex plane is also demonstrated.

• ### 14 Simplification and Estimation via Scaling

An extremely useful technique for approaching PDEs (and sometimes ODEs too) is rendering them dimensionless via scaling. In this lecture I demonstrate how scaling of the transport equations can give you almost everything you are interested in without ever actually solving the problem.

• ### 15 Solving PDEs via Self-Similarity

Some very important transport problems admit self-similarity: a technique for reducing the number of independent variables a problem depends on (e.g., turning a 2-D PDE into an ODE). Here I introduce Morgan's Theorem and show how you can accomplish this via simple affine stretching.

• ### 16 Solving PDEs via Separation of Variables

Certain linear PDEs (including transport equations under certain conditions) can be solved via the technique of separation of variables. This yields a Sturm-Liouville boundary value problem for the spatial part (for startup flows). The technique is applied to the classic problem of startup flow in a tube.

• ### 16a Numerical Solution of Separation of Variables Problems

It's always nice to have an analytic solution to the Sturm-Liouville problems arising from separation of variables, but they can get messy - and for many classic problems no analytic solution exists! In this video I introduce slsolve.m, a finite difference solver for SL problems in standard form that I wrote decades ago for the sophomore NumStats class. This is applied to the startup flow in a pipe problem and compared to the analytic solution in the code tubestartup.m.

• ### 17 Solving PDEs via Marching Solutions

Many problems can't be solved via any of the techniques above (although scaling is *always* useful!), so the last resort is numerical solutions. Here I discuss the simplest approach: the explicit forward Euler finite difference solution technique as applied to parabolic PDEs such as the heat equation or startup flow in a pipe. The code which produces a movie of the process is startupmovie.m.

• ### 18 Monte Carlo Solutions to Diffusion Problems

A very different way of solving transient diffusion (and convective diffusion) problems numerically is via Monte Carlo (or Brownian Dynamics) simulations. The idea is that you can use "tracers" to represent mass or energy and follow them along as diffusion gives them a random walk "kick" at each time step. Very computationally intensive, but also very very easy to code up for problems where this approach is amenable. The example code for a quenched cube is cubequench.m.