This course is continually evolving as I learn from my experience in
past years.
The following are some details about the course that reflect my
present plans (feedback will be much appreciated!).
I tend to be
overambitious in planning things like this course, but I am also
realistic and flexible. I will make adjustments as needed.

Coverage.
A computational physics course could be a programming
course, a numerical algorithms course, a simulations course, or
primarily a physics course with computers. I plan to have
aspects of all four. This means I'll sacrifice depth in favor of
exposure to the most important aspects and concentrate on giving you
practice in learning more on your own.
 Philosophy. You learn the most by confronting
and solving a wide range of problems. Learn by reading/hearing the basics,
then trying to apply them (failing, getting frustrated) and then (with
help!) figuring it out. There is a great deal of satisfaction
simulating physical processes and systems, and it also helps to develop
deeper physics understanding.
 In order to get everyone started
efficiently and to make sure there is adequate feedback, it is
important to have "hands on" sessions, where you'll work in groups of
two (usually).
 Because there will be a wide range of prior experience among the
participants, it will be largely selfpaced (e.g., more like an open
lab with me and a TA wandering around helping people than a structured
class).
 Lecture time will be minimal; we'll
rely more on handouts available before class.
 To make the lab
sessions more efficient and to "level the playing field," you'll be
given codes to start with and then asked to modify them (rather than
having you build them from scratch).
 Text. I've reviewed many potential texts for
the course. Most are good
references for one or more aspects of computational physics but none are
ideal for this course (and all are expensive!).
 In the
past we used "Computational Physics" by Landau and Paez.
I am very pleased to find there is a new version called
"A Survey of Computational Physics" (with additional coauthor
Bordeianu) that is available as an
eTextBook (free!). It is linked on the course webpage.
 In general, I will mostly use my own
lecture notes combined with extensive (and free!)
lecture notes by Prof. Morten
HjorthJensen from the University of Oslo, plus pointers
to the Landau et al. text.
 There are some fairly new books that are quite good, such as
"A First Course in Computational Physics
and ObjectOriented Programming with C++" by David Yevick.
This will be a "recommended" text (among others).
 There are other good sources
available online (free!), which we'll take advantage of (e.g., chapters
of the 2nd edition
Numerical Recipes books can be downloaded by individuals for
free).
 Programming language/environment.
We will use C++ as our main language but also use
Python as a computational, visualization, and scripting language.
I'm not going to assume
prior experience with a programming language, but we will start
running codes from the start. There are many times when calling
Fortran subroutines (e.g., from a matrix library) is desirable; we
will see how to call Fortran from C++.
 It is FAR easier to understand and then
modify an existing code than to write one from scratch when you are
new to computer languages. So we'll start there and then build on
that experience. Of course, if you already have a lot of experience,
you'll be able to use that to your advantage.

In the past we've used Mathematica as a
symbolic/numerical/graphical framework, which has many uses in
computational physics and is an efficient tool in many cases.
We've also used MATLAB,
which is better
for graphics and easier for numerical programming (in my opinion).
Mathematica and MATLAB are available via site license for OSU students,
but in general are quite expensive. I will try to use Python instead for
some of these computational applications as well as for a scripting
language (which will be explained!).
 Topics. There are too many topics in Computational Physics to cover in
one quarter, so I will pick and choose (and do some sampling).
[You can look at
last year's web page to
see what we actually did. There will be some rearrangement and more
choices for this year's class.] Here
are some of the topics I think are important:
 Errors and uncertainties in computations. This is one of the most
important (and most overlooked) aspects of computational physics.
(Coverage of this topic is a strength of the Landau/Paez text.) As an
example, one should understand how to analyze whether a calculation
is limited by the algorithm error or by the roundoff error.
 Basic computational algorithms for: integration, differentiation,
differential equations, root finding. We'll talk about some of the
theory, but far more important is to understand how well an algorithm
should work and test whether it does
(e.g., should the accuracy improve as 1/N^2, where N is
the number of points used, and is this what you find in practice?)
and what algorithm is appropriate for what
situation (e.g., oscillatory integrals or integrands with
singularities). In many cases you should be using a packaged library
routine and not writing your own, so we'll learn how to use such a
library. (By the way, Numerical Recipes is a
good source of information on algorithms, but I don't recommend their
codes in general.)
 What you should know about: random numbers, Monte Carlo integration
and simulation, matrix computing, parallel processing, and so on.
 Aspects of writing code: good programming practices;
how to test and debug a code (C++, Fortran, Python, MATLAB, Mathematica or whatever);
how to tune a code to run faster.
 Objectoriented programming: what is it and when is it relevant for
computational problems? This is a big subject that
we will only touch upon this in class, but
you can do much more for your project if you already have
some background.
 Building a nontrivial project. Some of the issues
that should be
addressed in this context:
 how to get started on a mediumscale project
(including revision control)
 implementation issues (e.g., program design, code conventions,
makefiles)
 breaking down a project into subproblems
 specific numerical problems (for this particular example: solving a
differential equation numerically to find eigenvalues and wave
functions, numerical integration and interpolation, special functions,
iteration as a solution method)
 debugging and profiling
 use of graphics for visualization
 use of scientific libraries (in very many cases you should use a
packaged routine, which will be far superior to what you could write
in a short period of time)
 when and how to use an object oriented approach (C++)
Your comments and
suggestions are appreciated.
[OSU Physics]
[Math and Physical Sciences]
[Ohio State University]
OSU Physics: Physics 780.20 Computational Physics.
Last modified: 10:20 am, December 30, 2011.
furnstahl.1@osu.edu