*Handouts:* Printout of nonlinear.nb notebook,
excerpt from Landau/Paez Chapter 5, printout of
spline_function2 (.cpp, .h, _test.cpp), printout of GSL interpolation
examples, "Using GSL Interpolation Functions", ode_test.cpp printout,
sample .bashrc file

In this session,
we'll finish up session 8, highlight some bash shell stuff and the rsync
program, have a brief look at using a GSL
adaptive differential equation solver, and then look at interpolation.

*
Your goals for today and ...
*

- Finish up Session 8 with the new version of gnuplot_pipe.c, plus look at some additions.
- Learn or review some things about the bash shell.
- Try out rsync.
- Try out a GSL differential equation solver.
- Try out various GSL interpolation functions on a simple example.
- Represent a sample wave function using cubic splines and test how many points are needed to get a desired accuracy.

Please work in pairs (more or less). Dick and Daniel will bounce around 2082 and answer questions.

In Session 8 we were stymied by the failure of the piping to work this year. Daniel figured out how to fix it, so we'll continue a bit further this week. Work on these tasks for the first hour of the session only, then move on.

- The Session 9 tarball includes a version of gnuplot_pipe.c with a "sleep" command added so that the piping works (more or less). Continue with Session 8 "Damped, Driven Pendulum" and "Looking for Chaos".
- The Mathematica notebook
`nonlinear.nb`looks at the same type of analysis as`diffeq_pendulum.cpp`only it uses the Duffing equation. Look through it and follow along with the printout. This exercise is mostly just to expose you to how to do lots of useful things with Mathematica, for future reference. Any questions about Poincare sections or the power spectrum? - If you're familiar with Mathematica and have time, you can try
converting
`nonlinear.nb`to study the pendulum instead. If neither of these is true, you can directly one the "answer", which is called`pendulum.nb`.

Here are some things you should know about using the Bash shell. (If you use tcsh instead, try to discover or ask about the equivalent commands and procedures.)

- Bash aliases. The .bashrc file sits in your home directory and
is "sourced" when you start an interactive terminal.
Take a look at the sample .bashrc file printout (the file itself is
in the session 9 tarball). Copy any aliases of interest to
your own .bashrc and activate the changes with the
command:
`source ~/.bashrc`. - Create your own alias to automatically log you in (via ssh) to a computer you use a lot (e.g., trinidad or elba). For the experts: write a function called packup that takes as an argument a sub-directory name and creates a tarball with .tarz appended to the name of the sub-directory.
- Finding a command. Suppose you want to know both the defined alias and the original command for du. Use "type -a du" and you should be told all of the possibilities. Try this on some other commands.
- The ulimit command. Type "ulimit -a". Can you figure out how to change the stack size to "unlimited"? The default values may vary from machine to machine.
- History. To re-execute the last command that contained "string", use !string. E.g., !make will re-run the last make command. If you type "history", you'll get a list of recent commands, with numbers. To re-execute number 25, type "!25". Put the H function from the sample .bashrc in your own .bashrc and activate the change. This command searches your history for matches, e.g., "H string" will find those lines with "string" somewhere. You can then use the numbers to re-execute the one you want. Try it! (E.g., try "H ulimit")
- Line editing. If you use the up-arrow to bring back a line that you want to change, you can use emacs-style commands to move around on the line. For example, Ctrl-b and Ctrl-f move you back and forward a character at a time, while Alt-b and Alt-f move you back and forward a word at a time. Ctrl-a takes you to the start of the line while Ctrl-e takes you to the end. Ctrl-k kill to the end of the line. Ctrl-d deletes the current character and Alt-d deletes the current word. Try these out!

Rsync is a backup or mirroring tool that only copies the
*differences* of files that have changed. It can do this transfer
in compressed form and using ssh for security (both recommended!).
So updates are fast, efficient, and secure.
Here we'll make a trial run so that you get the basic idea.

- Take a look in the .bashrc file for the definitions "rsyncbackup" and "rsyncmirror". Make sure they are in your own .bashrc file (and run "source .bashrc" to activate them). These aliases use some of the common rsync options. The difference is that rsyncmirror deletes files at the destination that don't exist at the source; be careful of this!
- Create a directory in your home directory called "780_backup" to use for testing rsync (i.e., "mkdir 780_backup").
- We'll create a backup of the session 9 directory on fox.
(Since all your files are mounted on all of the physics public
computers, you don't need to copy to another computer, but this is
a demonstration!)
Go to the
parent directory of session_09 (which is probably ~/780).
Give this command:
rsyncbackup session_09 elba.mps.ohio-state.edu:780_backup

If you are asked if you want to continue connecting, answer yes. You'll probably be asked for your password as well (it is the same one everywhere). You should see a list of files transferred and some statistics. - Check that the directory was transferred. Now go back to the original session_09 and change one file. (E.g., edit one of the .cpp files and add a comment.) Then repeat the rsync transfer (from the appropriate directory), using "!rsync" to avoid typing the entire alias. You should find that only the changed file is updated.

The program ode_test.cpp demonstrates the GSL adaptive differential equation solver by solving the Van der Pol oscillator, another nonlinear differential equation (see the Session 9 background notes for the equation).

- Take a look at the code and figure out where the values of mu and the initial conditions are set. Change mu to 2 and the initial conditions to x0=1.0 and v0=0.0 (y[0] and y[1]). Note the different choices for "stepping algorithms", how the function is set up and that a Jacobian is defined, and how the equation is stepped along in time.
- Compile and link the code according to the instructions in the comments. (You are invited to create a makefile!) Run it.
- We can save the output using ">":

ode_test > ode_test1.dat

Create ode_test1.dat, ode_test2.dat, and ode_test3.dat using the initial conditions [x0=1.0, v0=0.0], [x0=0.1, v0=0.0], and [x0=-1.5, v0=2.0]. - Use gnuplot to make phase-space plots of all three cases on a
single plot. What do you observe? This is an
*isolated attractor*.

We'll use the Landau/Paez text's example of a
theoretical scattering cross section as
a function of energy to try out the GSL interpolation routines.
The (x,y) data, with x-->E and y-->sigma_{th}, is given in Table
5.1 (see the Chapter 5 excerpt).

- Start with the gsl_cubic_spline_test.cpp code (and corresponding
makefile). Instead of the sample function, you will interpolate
the Table 5.1 data. Set npts and the (x,y) arrays equal to
the appropriate values when you declare them. Declare them on
separate lines. An array x[4] can be initialized with the values
1., 2., 3., and 4. with the declaration:

double x[4] = {1., 2., 3., 4. }

- Modify the code to generate a cubic spline interpolation for the cross section from 0 to 200 MeV in steps of 5 MeV. Output this data to a file for plotting with gnuplot.
- Now generate the corresponding linear and polynomial interpolations. You can generate these all at once (e.g., by making three splines in succession) or by running the code three times and changing the interpolation type between compilations.
- Generate a graph with all three interpolations plotted
and see how graphical
predictions for the resonance energy E
_{r}(your peak position) and gamma (full width at half maximum) compare to the theoretical predictions of (78,55).

Here we'll look at how to use cubic splines to define a function (in the form that GSL routines use) from arrays of x and y values. A question that always arises is: How many points do we need? Or, what may be more relevant, how accurate will our function (or its derivatives) be for a given spacing of x points?

- Take a look at the printouts for spline_function2. In spline_function2.cpp, the GSL calls have been packaged into functions. Notice that spline_funct has the same arguments (double x void *params_ptr) as a GSL function. Can you see how spline_funct works?
- The test program splines two different sets of arrays (with two different spline structures). Note how params_ptr is set equal to the address of the relevant spline_struct (which is declared in spline_function2.h). Make and run the program (it's not very exciting!).
- Modify the code so that it splines the ground-state hydrogen
wave function:
u(r) = 2*r*exp(-r)

(You can delete the second spline.) - Your job is to determine how many (equally spaced) points to use to represent the wave function. Suppose you need the derivative of the wave function to be accurate to 0.1% for 0 < r < 4 (absolute, not relative error) Devise (and carry out!) a plan that will tell you the spacing and the number of points needed to reach this goals.
- Now suppose you need integrals over the wave function to be accurate to 0.01%. Devise (and carry out!) a plan that will tell you the spacing and the number of points needed to reach this goals. (To try out integrals, use one of the GSL integration routines on an integral involving u(r) that you know the answer to; there's an obvious one!)

furnstahl.1@osu.edu