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 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.
-
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 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).
- 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
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. 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 new version called
"A Survey of Computational Physics", which is again good but still
expensive.)
- There are some fairly new books that look quite good, such as
"A First Course in Computational Physics
and Object-Oriented Programming with C++" by David Yevick.
This will be a "recommended" text (among others).
- 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 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 somewhat.
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.
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 for
most of the computational applications that we used Mathematica/MATLAB
for in the past.
- 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 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 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, 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.
- Object-oriented 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.
- Building a non-trivial project. Some of the issues
that should be
addressed in this context:
- how to get started on a medium-scale project
- implementation issues (e.g., program design, code conventions,
makefiles)
- 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)
- debugging
- 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: 09:29 am, November 08, 2009.
furnstahl.1@osu.edu
