# 780.20: 1094 Session 10

Handouts: Printout of nonlinear.nb notebook, excerpt from Landau/Paez Chapter 5, printout of GslSpline and test files, "Using GSL Interpolation Functions", ode_test.cpp printout

In this session, we'll look at using a GSL adaptive differential equation solver and then look at interpolation.

Your goals for today and ...

• Finish up some left-over Session 8/9 tasks
• Try out a GSL differential equation solver.
• Try out various GSL interpolation functions on a simple example.

Please work in pairs (more or less). The instructors will bounce around 1094 and answer questions.

## Follow-ups to Sessions 8 and 9

Work on these tasks for the first half of the session only, then move on to Session 10 tasks.

1. 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. What questions do you have about Poincare sections or the power spectrum?

2. If you're familiar with Mathematica and have time, you could convert nonlinear.nb to study the pendulum instead. But for now, just run the "answer" notebook called pendulum.nb. Try different parameter choices; what do you see with p2 vs. p5? (For the Poincare plot with p5, try removing the PlotRange.)

3. Complete the Session 8 sections on "Damped, Driven Pendulum" if not already completed.
4. Continue with unfinished Session 9 tasks.

## GSL Differential Equation Solver

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 10 background notes for the equation).

1. 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. Next time we'll see how to rewrite this code with classes.
2. Use the makefile to compile and link the code. Run it.
3. Create three output files using the initial conditions [x0=1.0, v0=0.0], [x0=0.1, v0=0.0], and [x0=-1.5, v0=2.0] (just change values and recompile each time). Notice how we've used a stringstream to uniquely name each file.
4. Use gnuplot to make phase-space plots of all three cases on a single plot. Print it out and attach it. What do you observe? This is called an isolated attractor.

5. Think about how you would restructure this code using classes. Next time we'll explore a possible implementation.

## GSL Interpolation Routines

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-->sigmath, is given in the bottom row of Table 5.1 (see the Chapter 5 excerpt; note we are NOT fitting sigmaexp).

1. Start with the gsl_spline_test_class.cpp code (and corresponding makefile). Take a look at the printout and try running the code. Note that we've used a Spline class as a "wrapper" for the GSL functions, just as we did earlier with the Hamiltonian class. Compare the implementation to the example on the "Using GSL Interpolation Functions" handout.
2. Instead of the sample function in the code, you will change the program to interpolate the Table 5.1 data from the handout. 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. };
3. Use 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 and try it out.
4. Now modify the Spline class to allow for a polynomial interpolation and change the gsl_spline_test_class.cpp main program to generate linear and polynomial interpolations as well and add the results to the output file.
5. Generate a graph with all three interpolations plotted. For each curve, how does the resonance energy Er (the peak position) and gamma (full width at half maximum) as seen on the graph compare to the theoretical predictions of (78,55)?

## Cubic Splining [if time permits]

Here we'll look at how to use cubic splines to define a function 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?

1. We'll re-use the Spline class from the last section and the original gsl_spline_test_class.cpp function, which splined an array.
2. The goal is to modify the code so that it splines the ground-state hydrogen wave function: u(r) = 2*r*exp(-r)
3. Your task 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 one part in 106 for 1 < 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. What did you do?

4. 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!)