780.20: 1094 Session 8
Printouts of Circle class files,
filename_test.cpp, diffeq_pendulum.cpp, GnuplotPipe class;
plots of damped oscillations
probe another nonlinear system: the damped, driven pendulum.
Your goals for today (and ...):
- Do a bit more with C++ classes.
- Play around with C++ strings and string streams.
- Look at the effects of friction (damping) in the differential equation
for a physical pendulum.
- Explore the parameter space for
a driven, damped pendulum, looking for limit cycles
Please work in pairs (more or less).
The instructors will bounce around 1094 and answer questions.
Revisiting area.cpp with a C++ Class
Our first simple C++ code from Session 1 used procedural programming,
with the focus on the formula (which would typically be coded as a
function) for calculating the area. Now we revisit it from an
object oriented perspective.
- Look at the printout with test_Circle.cpp and the old area.cpp,
with the Circle class defined on the back.
Note how all of the details of the area calculation are now hidden.
Any questions on the Class definition?
Predict where in the test_Circle.cpp
code the two circles will be created and where they will be
destroyed. Why do we define get_radius and set_radius methods?
- Using make_test_Circle, compile and link test_Circle.cpp with
the class files. Run it and note where the circles are created
and destroyed. Do you understand why they are destroyed
in this order?
- Add a method to Circle.cpp (and Circle.h!) so that we can
get the circumfrence from my_circle.circumfrence(). Try it
out in test_Circle.cpp. Did you succeed?
- (Extra, only do this if you are fast.)
Make a Sphere class with Sphere.cpp and Sphere.h, and try it
out by adding to test_Circle.cpp to create a Sphere and print
out its radius. Did you succeed?
Strings and Things
The filename_test.cpp code has examples of the use and manipulation of
C++ strings, including building filenames the way we do stream output.
Be careful NOT to put << endl when creating filenames.
- Using make_filename_test, compile and link filename_test.cpp and
run it. Look at the output files and the printout of the
code to see how it works.
- Modify the code so that there is a loop running from 0 to 3 with
index variable j. For each j, open a file with a name that includes
the current value of j.
Write "This is file j", where "j" here is the
current value, into each file and then close it. Did you succeed?
- Modify the code to input a double named alpha
and open a filename with 3
digits of alpha as part of the name. (E.g., something like
pendulum_alpha5.22_plot.dat if alpha = 5.21934.) Output something
appropriate to the file. Did it work?
Upgrades from the diffeq_oscillation to diffeq_pendulum Code
- There are three new menu items: plot_start, plot_end, and
equation is still solved from t_start to t_end, but results are only
printed out from plot_start to plot_end. Initially these are the same time
intervals, but you can use plot_start to exclude a transient
So if the system settles down to periodic behavior at t=20, setting
plot_start=20 means that 0 < t < 20 is not plotted, which makes the
phase-space plots much easier to interpret.
- We've also incorporated code to do real-time plotting in gnuplot directly from
C++ programs. We have made a class to do this but it is
still under development:
and documentation needs work, and it probably has bugs!
Look at the GnuplotPipe.h printout and the GnuplotPipe.cpp file
to get an idea how it works.
Gnuplot_delay sets the time in milliseconds between plotted points.
Damped (Undriven) Pendulum
The pendulum modeled here has the analog of the
viscous damping: Ff = -b*v, where v(t) is the velocity, that
was used in session 7. The damping parameter is called alpha here.
- Use make_diffeq_pendulum to compile and link diffeq_pendulum.cpp.
Run it while taking a look at the printout of the
It should look a lot like
diffeq_oscillations.cpp, with different parameter names. Run it with
the default parameters, noting the real-time phase-space plot. There
is also an output file diffeq_pendulum.dat.
- Modify the code so that the output file includes two digits of
the variable alpha in the name. Did you succeed?
- Generate the analogs of the four phase-space plots on the handout
but with pendulum variables and initial conditions theta_dot0=0 (at
rest) and theta0 such that you are in the simple harmonic oscillator
regime (note that theta is in radians). Set f_ext=0 (no external
driving force) and then do four runs with four values of alpha
corresponding to undamped, underdamped, critically damped, and
overdamped (convert from the conditions on b discussed in the
background notes). What values of theta0 and alpha did
Damped, Driven Pendulum
This is a quick exercise to look at transients.
- Restart the program so that we use the defaults. There is both
damping and an external driving force, with frequency w_ext = 0.689.
The initial plot is from t=0 to t=100. Run it.
The green points are
plotted once every period of the external force. What
good are they?
- Note that it seems to settle down to a periodic orbit after a
while. Plot ("by hand" with gnuplot) theta vs. t from the output file
diffeq_pendulum.dat and see how long it takes to become periodic.
- Run the code again with "plot_start" set to the time you just
Have you gotten rid of the transients? What is the frequency
of the asymptotic theta(t)?
Looking for Chaos
Now we want to explore more of the parameter space and look at different
structures. On page 191 of the Landau/Paez book (see the handout),
there is a list of characteristic structures
that can be found in phase space, with sample pictures on page 190.
- In phase space, a fixed point is a (zero-dimensional) point that
"attracts" the time-development of a system. By this we mean that
many (or all) initial conditions end up at the same point in phase
space. The clearest case is a damped, undriven system like a pendulum,
which ends up at theta=0 and zero angular velocity no matter how it
starts. If the steady-state trajectory in phase space is a closed
(one-dimensional) curve, then we call it a limit cycle.
- We'll start with some prescribed values for the pendulum.
Try the following combinations:
|period-1 limit cycle||0.0||0.0||0.689||0.8||0.0|
You will need to adjust "plot_start" and extend the plot time
(increase "t_end" and "plot_end").
Can you tell how many "periods" the limit cycles have from the
graphs? How might you identify whether a function of time f(t) is
built from one, two, three, ... frequencies?
One characteristic of chaos is an "exponential sensitivity to initial
conditions." For the last combination, vary the initial conditions
(e.g., change x0 by 0.01 or 0.001) and see what happens.
- Java applets that show the behavior of a chaotic pendulum
interactively and also a comparison of two such pendulums (to illustrate
sensitivity to initial conditions) can be found at
780.20: 1094 Session 8.
Last modified: .