Reddit reviews Fundamentals of Engineering Numerical Analysis: Second Edition

>I'm not sure what kinds of other heavy scientific computing you've done, but CFD is a very difficult field and takes years to understand.

CFD isn't this difficult.

On one side you have partial differential equations (PDEs) describing fluid flow. On the other side you have numerical methods used to solve those PDEs. Put the two together, implement it in code, and you get a rudimentary CFD simulation. For CS students, who typically already have knowledge of numerical methods, coding one of these basic simulations can be done within a semester's worth of focused effort. Venturing into finer, more complex domains and trying to model more advanced flow phenomenons do indeed require years of study, but a beginner -- a 3rd year CS undergrad of all people -- has no need to deal with that stuff when all they want to accomplish is to get their feet wet with the inner workings of the simplest CFD simulation.

So let's not intimidate the poor kid and not oversell the profession. A lot of people love pretending like this stuff is black magic, presumably because it promotes job security, but it just isn't. There are lots of people doing CFD that come from CS and Applied Math backgrounds instead of Engineering or Physics. They all started somewhere. So can the OP.

-------------------------------------

@ /u/AnotherBrownBike

Khan Academy Physics, Fluid Dynamics lectures are your best friend in this.

I would recommend that you start with getting a decent physical understanding of incompressible (also called divergence-free) advection-diffusion equation. This is a simple PDE that describes how particles (or other quantities like energy) are transferred inside a physical system due to the process of diffusion and advection (aka convection). Solving this equation using a numerical solution method for PDEs (such as finite volume or finite element) will allow you to practice the fundamental underpinnings of a CFD code.

Finite Volume methods are more popular in CFD than finite element methods, because they're mathematically easier for people who have a robust understanding of fluid mechanics. That's not going to be the case for you, because you're not studying fluids academically. I would recommend that you focus on finite element methods instead. These are mathematically more challenging -- using them with fluid PDEs require stabilization terms (like SUPG or GLS) to prevent the solution from oscillating. However, the application of finite element methods to fluid PDEs require essentially no knowledge of the physics behind the PDE. It's pure mathematics, and you as a CS student should be well equipped to handle this.

If you're not familiar with finite element methods for solving PDEs, I would strongly recommend starting with a Python library called FEniCS. This is a brilliant finite element solver that allows you to input the bilinear form of your partial differential equation (Google what "bilinear form" is for finite element methods) in Python and generate a solution. This will allow you to practice the mathematics of finite element methods without getting tangled up in the code implementation of the solution process. Solve the Poisson equation first, and then the advection-diffusion.

Simple solvers you might like working with:

EasyCFD -- Educational program intended to teach the basics of a "black-box" CFD solver.

CFD Python -- A Python program designed with a 12-step lesson plan to solving Navier-Stokes equations.

PyFR -- Another Python-based flow solver. Documentation is a bit sparse, so you need an understanding of how CFD works to use it. But once you have that, PyFR's open-source nature allows you to break apart an actual full CFD solver and look at its components before trying to write your own.

Useful literature you might want to check out from your campus library:

White, Fluid Mechanics and/or Cengel and Cimbala, Fluid Mechanics -- Basically the two beginner level fluid mechanics bibles, depending on who you ask. An overwhelming number of engineers out there have had one or the other as their textbook in school. They're both fantastic. Flip a coin.

Moin, Fundamentals of Engineering Numerical Analysis -- Yet another undergraduate bible, this time on numerical methods commonly used by engineers (of all types). It covers material so crucial in all scientific computing that one of my doctoral qualification examiners specifically requested that I know this book from cover to cover.

Anderson, Computational Fluid Dynamics -- Superb introductory book that covers most everything related to CFD. If you're going to buy anything in this list, buy this one.

Hughes, Finite Element Methods -- The bible on finite element methods. The book focuses on structural applications (which do not require stabilization terms) but the mathematics involved are identical regardless of the physics behind the PDE, so this is still a very useful reference.

Zienkiewicz, Taylor and Nithiarasu, Finite Element Method for Fluid Dynamics -- Great supplement to Hughes' book for anyone using FEM on fluid flow. Covers stabilized methods, starting with easy equations (like advection-diffusion) and scaling up all the way to turbulent flows (which you shouldn't bother with right now).

Anderson, Fundamentals of Aerodynamics -- Just putting this down in case you ever need to specifically learn about aerodynamic applications of fluid flow.

Anderson, Introduction to Flight -- Used nationwide as an introductory aerospace engineering book. I recommend it to everybody outside of the industry who wants to work/study in it. Superfluously covers every aspect of the discipline, from structures to propulsion, from aerodynamics to flight control, from aviation to space.

Panton, Incompressible Flow -- Often used as a graduate level book on theoretical fluid mechanics. Focused mathematical approach. Not an easy read, required some prerequisite knowledge of fluid flow (overview of the fundamentals is very brief), but it's the next logical step up when you're ready to take your fluid work further.

Earlier this year I finished my PhD in aero (researching computational fluid dynamics). I'll go ahead and reiterate a couple of the other recommendations in this thread, I think they've given you pretty good advice so far.

Numerical Recipes is great, and you can even read their older editions for free online. Don't worry about them being older, their content really hasn't changed much over the years beyond switching around the programming language. A word of warning, though. The code itself in these books come with rather restrictive licenses, and what it ends up meaning for you is you can copy their code and use it yourself, but you aren't allowed to share it (although I don't think this is carefully enforced). If you want to share code, you'll either have to pay for their license, or use their code only as inspiration for writing your own. If you pay close attention to their licensing, they don't even let you store on your computer more than one copy of any of their functions (again, I can't imagine they actually have a way of enforcing this, but it makes me disappointed they do things this way nevertheless), so it can get problematic fast.

If you want more reading material, I've only paged through it myself but Chapra and Canale's book seems like a nice intro text (if it wasn't your textbook already), and uses MATLAB. Reddy has a well-liked intro to finite element methods. Some more graduate level texts are Moin, LeVeque (he has a bunch of good ones), and Trefethen.

Project Euler is indeed great.

I would also recommend you learn some other (any other, really) programming language. MATLAB is a fine tool, but learning something else as well will make you a better programmer and help you be versatile. I don't really recommend you go and learn half a dozen other languages, or even learn every feature available one language--just getting reasonably comfortable with one will do. I'd say pick any of: C, C++, Fortran 90 (or higher), or Python, but there are others as well. Python is probably the easiest to get into and there are lots of packages that will give it a similar "feel" to Matlab, if you like. One nice way of learning (I think) is going through Project Euler in your language of choice.

Slightly more long term, take other numerical/computational courses. As you take them, think about what you like to use computation for (if you don't have a good idea already). If you like to analyze data, develop more or less "simple" simulations to direct design decisions, and don't care so much for heavy simulations, you'll get a better idea of what to look for in industry. If you like physics simulations and solving PDEs, you may lean toward the research end of things and possibly dumping Matlab altogether in favor of more portable and high performance tools.

Yeah, baby steps indeed! None of us learned this stuff overnight. I think a decent number of people in this subreddit have devoted at least a year (if not more) of advanced undergrad or beginner graduate level coursework to really master the principles behind CFD solvers.

I cannot recommend Moin's Fundamentals of Engineering Numerical Analysis enough. It starts with the very basics (numerical integration and finite differences) and then builds all the ODE/PDE discretization techniques right on top of these basics. If you're going to be learning about PDEs this semester, and then linear algebra next, this numerical methods book from Moin will be a great companion.

By the end of your linear algebra class, you should be able to write a program that discretizes an ODE with central differencing, which creates a linear matrix system (Ax=b), which in turn is solved using some iterative method (i.e.: Gauss-Seidell). That's not exactly how CFD solvers work (they use different discretization methods) but the general workflow is identical. Doing an exercise of that sort would be very helpful, and the general framework of your code can later be upscaled to more advanced discretization techniques.