Thank you for your interest in 780.20 Computational Physics.
This course is continually evolving as I learn from my experience in
The following are some details about the course that reflect my
present plans (feedback will be much apprecated!).
I tend to be
over-ambitious in planning things like this course, but I am also
realistic and flexible. I will make adjustments as needed.
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 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
- Since there will be a wide range of prior experience among the
participants, it will be largely self-paced (e.g., more like an open
lab with me and a TA wandering around helping people than a structured
- 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. While, it is
definitely a good book to have on your shelf, it is expensive and
doesn't provide a perfect match.
- There is a fairly new book that looks quite good,
"A First Course in Computational Physics
and Object-Oriented Programming with C++" by David Yevick.
This will likely be a "recommended" text for this year.
- In general, I will mostly use my own
lecture notes combined with extensive (and free!)
lecture notes by Prof. Morten
Hjorth-Jensen from the University of Oslo.
- There are other good sources
available online (free!), which we'll take advantage of (e.g., chapters
of the Numerical Recipes books can be downloaded by individuals for
- Programming language/environment.
We will use C++ as our main language.
I'm not going to assume very much
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.
This year I use both Mathematica and 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.
- 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
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 or round-off 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 (e.g., should the accuracy improve as 1/N^2, where N is
the number of points used?) 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 this type of information, but I don't recommend their
codes in general.)
- What you should know about: random numbers, Monte Carlo integration
and simulation, matrix computing, and so on.
- Aspects of writing code: good programming practices;
how to test and debug a code (MATLAB, C++, Fortran, Mathematica or whatever);
how to tune a code to run faster.
- Object-oriented programming: what is it and when is it relevant for
- Building a non-trivial project. Some of the issues that would be
addressed in this context:
- how to get started on a medium- to large-scale project
- implementation issues (e.g., program design, code conventions,
- breaking down a project into sub-problems
- 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)
- 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.
[Math and Physical Sciences]
[Ohio State University]
OSU Physics: Physics 780.20 Computational Physics.
Last modified: 06:06 pm, December 30, 2008.