TweetFollow Us on Twitter

Animation Algorithm
Volume9
Number11
Column TagC Workshop

Related Info: Color Quickdraw Gestalt Manager

From Algorithm to Animation

The making of a movie

By Jay Martin Anderson, Lancaster, Pennsylvania

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

About the author

Jay Anderson is Professor of Computer Science in the Department of Mathematics at Franklin and Marshall College in Lancaster, Pennsylvania. Trained as a physical chemist, he combines here his interest in quantum mechanics, mathematics, and Macintosh software development.

He can be reached at j_anderson@acad.fandm.edu on Internet.

Description of the problem

In presenting an algorithm for the solution of a particular kind of differential equation to a class in Computational Mathematics in the spring of 1992, I was led first to illustrate the algorithm with a graph, then with a series of graphs, and finally with an animated series of graphs. The product uses simply, but significantly, Color QuickDraw and QuickTime. The result is an engaging, yet helpful look at the workings of a numerical algorithm as applied to a textbook problem in quantum mechanics.

The algorithm.

The particular problem we solved arises in physics or chemistry courses in quantum mechanics, for it helps to illustrate the concept of “tunneling.” From a mathematics point of view, the problem is one of a subclass of differential equations.

Ordinary differential equations are equations which involve derivatives of a function with respect to one independent variable; first-degree ordinary differential equations involve only the first derivative. A system of first-degree ordinary differential equations involves two or more dependent variables and their first derivatives with respect to one independent variable. It is possible to write a single second-degree differential equation as a system of two first-degree differential equations.

The quantum-mechanical problem is this: particle, moving in only one dimension, is influenced by no potential energy over a part of its range, and by a constant potential energy (a “barrier”) over another part of its range. The quantum mechanics student is challenged to find what allowed energies the particle may assume, called eigenvalues or characteristic values of energy. If an energy eigenvalue is less than the potential energy barrier, the particle is said to “tunnel through the barrier,” and that state is referred to as “classically forbidden.” If an energy eigenvalue is greater than the potential energy barrier, that state is called “classically allowed.” In either case, the state is allowed by quantum mechanics and is observed in the world of electrons, atoms, and molecules.

Trimming the problem to its bare essentials, we endeavor to find solutions to the equation

where E is the (unknown) energy eigenvalue, and A is the constant potential energy. This is a very simple example of the famous Schrödinger equation of quantum mechanics, also called the “wave equation.” The function y(x), which satisfies this equation, is called an eigenfunction or a wave function. We can make this one second-degree differential equation into two first-degree differential equations by substituting a new variable for the first derivative of y:

Bear in mind that, in our specific problem, A = 0 for some range of x, and A 0 for some other range of x. In particular, we choose

A = 0 for -1 ¾ x < 0 A > 0 for 0 ¾ x ¾ 1

Figure 1. A region with a potential energy barrier

Finally, we are compelled to impose some constraints on the or eigenfunction y as well:

The last condition means that the slope of the eigenfunction must be continuous even where the potential energy changes value.

Well, enough for quantum mechanics and mathematics; on to some computer science, or at least some computational mathematics. There are good algorithms for solving systems of ordinary differential equations if both the value and the slope of the eigenfunction are known at one value of the independent variable; these algorithms are “initial value methods,” and a simple, but adequate method is the Runge-Kutta method. The Runge-Kutta method begins with a value of y and dy/dx at x = -1 and works forward towards x = +1 in small steps, to find the values of y along the way.

But that is not what is needed here; in fact, we don’t know the value of dy/dx at x = -1, but we do know the values of y at both x = -1 and x = +1. What we need is not an initial value method but a “boundary value method,” for we know values at both boundaries.

The “shooting method” is an example of a boundary value method. In the shooting method, we guess an eigenvalue of E, the energy, and we presume an initial value of dy/dx. Then we “shoot”: that is, we use an initial value method such as the Runge-Kutta method to shoot towards the other boundary. If our “shot” hits the other boundary condition, then we have a solution; if it doesn’t, we try again. We continue trying until our shot hits the other boundary accurately enough to satisfy us.

This method is computationally intensive, for it requires repeating the Runge-Kutta method over and over again until arbitrary accuracy has been achieved in shooting at the right boundary. The method carries with it, and compounds, all the errors of the Runge-Kutta method, but it works fast enough and is accurate enough for this problem to give students some insight into both methods for solving boundary value problems, and the quantum-mechanical tunneling problem in particular.

The desired effect

It is useful, in any method for solving ordinary differential equations, to be able to graph the solution; it is particularly useful in the shooting method for solving boundary value problems, to be able to graph approaches to the solution; that is, to graph different “shots.” But it is most useful to be able to graph a series of shots as they approach the shot which is the solution to the boundary value problem. This can be done in an effective and engaging way with animation.

In addition, since this particular boundary value problem has many solutions (in fact, there are an infinite number of eigenvalues E and eigenfunctions y which satisfy the system of equations and its constraints), it is possible to show how the shooting method finds the first eigenvalue, and then the second, and then the third, and so forth. This leads us to a sequence of graphs which approach and find the first solution, then approach and find the second solution, etc.

Finally, it would be nice to call a student’s attention to the solutions with sound, or color, or both.

Our desired effect, then, is an animated graph, accompanied by visual or audible cues that solutions have been found. This series should begin with values of E less than the first eigenvalue, and extend to include the first few (I chose five) eigenvalues. The result will be a sound movie of many shots, showing five solutions to the problem.

The Shooting Method

As mentioned above, the shooting method is based on a method for solving an initial value problem in ordinary differential equations, such as the Runge-Kutta method. The Runge-Kutta method, and code in C or Pascal to implement it, can be found in any of a number of standard textbooks, so there is no need to belabor that point here. A library of numerical mathematics may also have source or object code for the Runge-Kutta method.

To graph an individual “shot,” we must first design a Macintosh window to receive the graph, and then develop a transformation to map the real-world variables of y and x onto the window variables of horizontal and vertical pixels. This transformation is the so-called “windowing transformation” of classical two-dimensional computer graphics. Then, for each step in each Runge-Kutta shot, we use QuickDraw LineTo in order to draw a step of the graph of the trial solution.

This would be sufficient for a single graph of a single shot, but it is insufficient for a sequence of graphs of shots, leading up to a movie of the search for a solution. In figures 2, 3, and 4, only the graphics are shown for clarity; the actual window also contains text labels.

Figure 2. A trial solution, or “shot”

Figure 3. A solution, or successful shot

Searching for Several Solutions

It has become almost paradigmatic in Macintosh developer’s circles now to “never draw directly to the screen.” There are a number of reasons for this, usually having to do with maintaining independence of the programmer’s graphics world from the user’s choice of monitor, color depth, etc. In our case, we need to preserve a common background for a graph while constantly displaying a different shot. Furthermore, the successful shots or solutions, must also be preserved even as additional shots are drawn.

The offscreen graphics world. An offscreen graphics world, or GWorld, consists of a grafport and a graphics device and their associated data structures. For our purposes, we may think of it as the content area of a window, set up as we want it to be, and into which we can draw just as if we were drawing into a real window on the screen.

How many GWorlds? For our purposes, we will need two offscreen GWorlds. One will contain background; the background will include axes, labels, a colored field onto which the graph of a trial solution will be placed, etc. The background will also contain each solution as it is found. The second GWorld will contain only one shot superimposed upon the background.

Figure 4. The background (at the beginning)

Copying bits.

Our paradigm for constructing a sequence of images of shots, in which the successful shots are saved, is this:

1. Create a background GWorld; fill it with background material.

2. Create a foreground GWorld; make it blank.

3. For each shot, draw the shot on the foreground. Then, copy the background onto the foreground using mode srcOr. Finally, copy the combination to the screen using mode srcCopy. The result is a flicker-free sequence of shots drawn on a constant background.

4. For each successful shot, draw that successful shot into the background; for emphasis, use a contrasting color. Each successful shot (that is, each solution to the Schrödinger equation) is then saved in the background and becomes a backdrop for the search for additional solutions. For additional emphasis, I used a reddish color for the “classically forbidden” solutions, and a greenish color for the “classically allowed” solutions. Finally, I fetched a sound resource from the system resource file, and played it at each successful solution.

Making a QuickTime Movie

The final step in this process is constructing a QuickTime movie from the sequence of snapshots. To do this, I borrowed heavily from the QuickTime Developer’s Kit (1.0) for sample code.

Since I use IT Maker’s Prototyper and THINK C as my development environment, I needed to embed the QuickTime code into the appropriate modules of code emitted by Prototyper. The source code listings which accompany the printed article show only fragments of only those files constructed by Prototyper in which I made significant modifications.

I copied the QuickTime #defines and global variables into the Prototyper PComUtil_xxx.c and PComUtil_xxx.h files, and replaced Prototyper’s code for opening, saving, and closing files with the QuickTime code for opening, saving, and closing movies. Portions of the final header file and source code file are shown in listings one and two.

I embedded the QuickTime code for adding a frame to a video track in my code for drawing offscreen and copying onscreen, mentioned above. Listing three shows the code which does the Runge-Kutta method, the Shooting method, builds the offscreen GWorlds, does the off- and on-screen drawing, and copies the frames to the QuickTime movie.

In order to leave final frame in the movie for a few seconds, I simply copied sufficient frames of the final shot into the video track. I provided for the final frame to remain on screen for about two and one-half seconds.

Of course, it is necessary for a proper application to confirm that color QuickDraw and QuickTime are both installed before proceeding. The programmer uses the Gestalt Manager to do this; fortunately, Prototyper emits this code for me.

Some extras

At this point I had a silent, color, QuickTime movie; one movie for each value of the potential energy A I wished to study. But real movies include titles and credits, and so I quickly developed an application to make a scrolling title for my movies using techniques similar to those above. Text is read from a file and drawn in an offscreen world. The offscreen world is transferred into another offscreen world, offsetting by one additional pixel for each frame. The frames are then saved to the video track of the movie, and also displayed on the screen. One could equally well select a commercial QuickTime application for this purpose.

For fun, I sampled the CD of one of my favorite operas for music to play over the titles and credits, and I sampled five symphonic chords from this opera for music to play whenever a solution is found. Instead of developing my own application to add the sound track, I used Adobe Premiere to position my “sound bites” correctly relative to the video frames.

The result is a color, sound movie of shots attempting to find the first five eigenvalues and eigenfunctions of the particle with the potential barrier.

Results

I have made several video clips using different values of A, the potential energy barrier. Four of these, for A = 5, 10, 20, and 40, are included in my final movie. My video clips are 318 x 219 pixels, with eight-bit color depth; each sequence runs about 25-30 seconds. These clips occupy about 750k each.

I have five digitized samples of rich, symphonic chords from the last act of Billy Budd by Benjamin Britten used to mark the five eigenvalues found by the shooting method. Each of these sound bites occupies a few tens of kbytes and lasts about 2.5 seconds. In addition, I digitally recorded about 45 seconds of the prologue to Billy Budd to use as sound over the titles and credits.

It is relatively straightforward to use Premiere to add a sound track with my sampled chords to the video clips of the sequence of shots for a given value of A. It is quite simple to use Premiere to add the prologue music to my QuickTime movies of titles and of credits.

The title movie is about 1.2 Mb, and the credits movie is about 3.0 Mb. Any simple movie player, such as that supplied by Apple with the QuickTime Starter Kit suffices to combine the titles, the animated sequence of shots, and the credits into a feature film replete with color and symphonic sound. After assembling the entire movie and applying some compression, the finished product is about 9 Mb for title, four animations, and credits. The finished movie runs for a little more than three minutes.

Listing One
/* 
 * A FRAGMENT ONLY from the file 
 * PComUtil_Shooter.h, emitted by 
 * Prototyper for this THINK C
 * project.
 *
 * J. M. Anderson, 1993
 */

#include <AppleEvents.h>
#include <Packages.h>
#include <GestaltEqu.h>
#include <Printing.h>
/* 
 * The following is necessary for
 * offscreen graphics worlds
 */
#include <QDOffscreen.h>

/* 
 * The following copied from "Movie  
 * Construction" in the QuickTime
 * Developer's Kit
 */
#include "Movies.h"
#include "QuickTimeComponents.h"

/* #defines appropriate for QT movies */
#define x1Rate (Fixed)1<<16
 /* fixed point 1.0 */
#define myTimeScale 10
 /* time scale, frames per sec */
#define trailerTime 2.6
 /* time in secs to hold last frame */

/* 
 * Global variables for the Particle in a
 * Particle in a Box Problem
 */
extern double    energyA; /* potential barrier */
extern double    energyE; /* trial eigenvalue */
extern double  eigenvalues[5];/* eigenvalues found */
extern Boolean justOne; /* looking for just one eigenvalue? */
extern Boolean readyToRun; /* finished setup, ready to run */
extern double    energyENear; /* guess for energy eigenvalue */

/*
 * Global variables for offscreen 
 * graphics 
 */
extern GWorldPtr offPort1, offPort2;
extern Rect offRect;
extern RGBColor  bkgdColor, forbidColor, allowColor;
extern OSErrErrorCode; 

/* 
 * Global variables for making movies;
 * copied from QuickTime Developer's
 * Kit
 */
extern Boolean   canMakeMovie,   
 makingMovie;
extern MoviegMovie;
extern Track     gTrack;
extern MediagMedia;
extern GWorldPtr myGWorld, oldGWorld;
extern GDHandle  oldGDevice;
extern Rect      offGRect;
extern PixMap    *pm, **pmH;
extern char **compressedFrameBitsH;
extern long maxCompressedFrameSize;
extern long compressedFrameSize;
extern CodecType codecType;
extern CompressorComponent
 codecID;
extern shorttheDepth;
extern CodecQ    theQuality, mQuality;
extern ImageDescription   
 **imageDescriptionH;
extern ImageSequence seqID;
extern unsigned char similarity;
extern long keyFrameRate;
extern TimeValue sampTime;
/*
 * NOTE:  The actual header file also
 * includes many more #defines, extern
 * declarations, typedef declarations,
 * and function prototypes.  Only those
 * definitions and declarations relative
 * to this article have been shown here.
 */
Listing Two
/* 
 * A FRAGMENT ONLY from the file 
 * PComUtil_Shooter.c, emitted by 
 * Prototyper for this THINK C
 * project.
 *
 * J. M. Anderson, 1993
 */

/* 
 * Global variables for the Particle in a
 * Box Problem
 */
double  energyA; 
 /* potential barrier */
double  energyE;
 /* trial eigenvalue */
double  eigenvalues[5];
 /* eigenvalues found */
Boolean justOne;
 /* looking for just one eigenvalue? */
Boolean readyToRun;
 /* finished set up, want to run */
double  energyENear;
 /* guess for energy eigenvalue */
GWorldPtr offPort1, offPort2;
Rect    offRect;
RGBColorbkgdColor, forbidColor, allowColor;
OSErr   ErrorCode;
short   outputRefNum;
Str255  outputFileName;

/* 
 * Global variables for making movies;
 * most are copied from Movie Construction
 * in the QuickTime Developer's Kit  
 */
Boolean canMakeMovie, 
 makingMovie;
Movie   gMovie;
Track   gTrack;
Media   gMedia;
GWorldPtr myGWorld, oldGWorld;
GDHandleoldGDevice;
Rect    offGRect;
PixMap  *pm, **pmH;
char    **compressedFrameBitsH;
long    maxCompressedFrameSize;
long    compressedFrameSize;
CodecType codecType;
CompressorComponent
 codecID;
short   theDepth;
CodecQ  theQuality, mQuality;
ImageDescription **imageDescriptionH;
ImageSequence    seqID;
unsigned char    similarity;
long    keyFrameRate;
TimeValue sampTime;

/* 
 * CLOSE_THE_OUTPUT_FILE:  this function
 * closes the QuickTime movie file after
 * all frames have been writen to the 
 * video media; copied largely from 
 * QuickTime Developer's Kit.
 */
void Close_The_Output_File()
{
 short resID = 1;
 
 ErrorCode = CDSequenceEnd(seqID);
 if (ErrorCode) DebugStr((StringPtr) 
 "\pCDSequenceEnd Failed");
 ErrorCode = EndMediaEdits(gMedia);
 if (ErrorCode) DebugStr((StringPtr) 
 "\pEndMediaEdits Failed");
 ErrorCode = 
 InsertMediaIntoTrack(gTrack, 0L, 0L, 
 GetMediaDuration(gMedia), x1Rate);
 if (ErrorCode) DebugStr((StringPtr) 
 "\pInsertMediaIntoTrack Failed");
 ErrorCode = AddMovieResource(gMovie, 
 outputRefNum, &resID, 
 outputFileName);
 if (ErrorCode) DebugStr((StringPtr) 
 "\pAddMovieResource Failed");
 ErrorCode = 
 MakeFilePreview(outputRefNum, 
 (ProgressProcRecordPtr)-1);
 ErrorCode = 
 CloseMovieFile(outputRefNum);
 if (ErrorCode) DebugStr((StringPtr) 
 "\pCloseMovieFile Failed");

 outputRefNum = 0;
 
 /* throw out everything else */
 DisposeMovie(gMovie);
 DisposHandle(compressedFrameBitsH);
 DisposHandle((Handle)imageDescriptionH);
 DisposeGWorld(myGWorld);
}

/* 
 * SAVE_THE_FILE:  this function
 * obtains an open movie file and
 * initializes it; copied largely from 
 * QuickTime Developer's Kit.
 */
void Save_The_File()
{
 short  theVolRefNum;
 short  theRefNum;
 
 if (Do_The_Save_File(
 (Str255 *)"\pSave Movie as:",
 (Str255 *)"\pUntitled.qt",
 &theVolRefNum,&theRefNum))
 {
 ClearMoviesStickyError();
 gTrack = NewMovieTrack
 (gMovie, 
  (long)(318)<<16, 
 /* width & height copied from
  * window resource */ 
  (long)(219)<<16,
  0);
 ErrorCode = GetMoviesError();
 if (ErrorCode) DebugStr((StringPtr) 
 "\pNewMovieTrack Failed");
 gMedia = NewTrackMedia(gTrack, 
 VideoMediaType, myTimeScale, 
 nil, (OSType)nil);
 ErrorCode = GetMoviesError();
 if (ErrorCode) 
 DebugStr(
 (StringPtr)"\pNewTrackMedia
 Failed");
 ErrorCode = BeginMediaEdits(gMedia);
 if (ErrorCode) 
 DebugStr(
 (StringPtr)"\pBeginMediaEdits 
 Failed");
 
 /* 
  * Make a new GWorld into which to
  * draw frames to be compressed 
  */
 SetRect(&offGRect, 0, 0, 318, 219);
 /* size copied from resource */
 GetGWorld(&oldGWorld, &oldGDevice);
 ErrorCode = NewGWorld(&myGWorld, 8, 
 &offGRect, nil, nil, 0);
 if (ErrorCode) 
 DebugStr((StringPtr)"\pNewGWorld Failed");
 pmH = myGWorld->portPixMap;
 LockPixels(pmH);
 HLock((Handle)pmH);
 pm = *pmH;
 
 /* 
  * Make Buffers & stuff for the 
  * compressor 
  */
 codecID = anyCodec;
 codecType = (CodecType)'rpza';
 theDepth = 1;
 theQuality = 0x300;
 mQuality = 0x300;
 keyFrameRate = 10;
 imageDescriptionH = (ImageDescription **)NewHandle(4);
 ErrorCode = 
 GetMaxCompressionSize(&pm, 
 &offGRect, theDepth, theQuality,
 codecType, codecID, 
 &maxCompressedFrameSize);
 if (ErrorCode) 
 DebugStr((StringPtr)
 "\pGetMaxCompressionSize 
 Failed");
 compressedFrameBitsH = 
 NewHandle(maxCompressedFrameSize);
 if (!compressedFrameBitsH) 
 DebugStr((StringPtr)
 "\pUnable to allocate compression buffer");
 HLock(compressedFrameBitsH);
 
 /* 
  * Tell codec manager we are about 
  * to start a sequence 
  */
 ErrorCode = CompressSequenceBegin
 (&seqID, &pm, nil, &offGRect, 
 nil, theDepth, codecType,
 codecID, theQuality, mQuality, 
 keyFrameRate, nil, 
 codecFlagUpdatePrevious, 
 imageDescriptionH);
 if (ErrorCode) 
 DebugStr((StringPtr)
 "\pCompressSequenceBegin 
 Failed");
 
 /*
  * We have now finished setting
  * up the movie & compression.
     * Now, back in the mainstream,
     * we can put the movie together one 
  * frame at a time.   
  */
 SetGWorld(oldGWorld, oldGDevice);
 makingMovie = TRUE;
 }
}

/* 
 * DO_THE_SAVE_FILE:  this function puts
 * up the StandardPutFile dialog box,
 * obtains a file name for the movie,
 * and creates or opens it.  It is a
 * modification of the code emitted by
 * Prototyper.
 */
Boolean Do_The_Save_File (Str255 *Prompt, 
 Str255 *DefaultName,
 short *theVolRefNum, short *theRefNum)
{
 StandardFileReply Reply;
 BooleanOpenedOK;

 InitCursor();
 StandardPutFile(Prompt, DefaultName,  &Reply);
 if (Reply.sfGood)
 {
 /* copy the file name */
 BlockMove((Ptr)
 &theStandardFileReply.sfFile.name, 
 &outputFileName,
 theStandardFileReply.sfFile.name[0]
 +1);

 /* create a movie file */
 ErrorCode = 
 CreateMovieFile(&Reply.sfFile, 
 'TVOD', 0, 
 createMovieFileDeleteCurFile, 
 &outputRefNum, &gMovie);

 if (ErrorCode == 0)
 {
 ErrorCode = SetFPos(outputRefNum, 
 fsFromStart, 0);
 ErrorCode = SetVol(nil, 
 theStandardFileReply.sfFile.vRefNum);
 *theRefNum = outputRefNum;
 *theVolRefNum = 
 theStandardFileReply.sfFile.vRefNum;
 OpenedOK = true;
 }
 else
 {
 DebugStr((StringPtr) 
 "\pCreateMovieFile Failed");
 ErrorCode = FSClose(outputRefNum);
 SysBeep(20);
 outputRefNum = 0;
 *theRefNum = 0;
 OpenedOK = false;
 }
 }
 return(OpenedOK);
}
Listing Three  
/* 
 * ONLY A PORTION OF the file 
 * PW_Particle_in_a_B.c, 
 * emitted by 
 * Prototyper for this THINK C
 * project.
 *
 * The full file contains all window 
 * management functions.
 * I show here the functions
 * for the Runge-Kutta method, the
 * Shooting method, offscreen graphics,
 * and adding frames to the video track
 * of a movie.
 * 
 * For this purposes of this article,
 * I have not shown in the header file
 * all the defines and declarations which
 * are referenced by code in this file.
 * I think their meaning should be clear
 * from the context.
 *
 * J. M. Anderson, 1993
 */


/* NOTE:  For the purposes of this 
 * article, I have omitted most of the
 * code for window management, including
 * the code to open the window.  However,
 * it is important to understand that,
 * when the window has been opened, the
 * offscreen bitmaps can be constructed,
 * and not before.
 *
 * In the function to open the window,
 * the function "buildBitMap" is called.
 *
 * In the function to update the window,
 * the function "shoot5Waves" is called.
 */

/* 
 * DEMONSTRATION PROGRAM FOR SHOOTING 
 * METHOD SOLUTION OF A SECOND-DEGREE 
 * DIFFERENTIAL EQUATION WITH TWO BOUNDARY
 * VALUES, USING RUNGE-KUTTA TRIAL  
 * SOLUTIONS.
 */
 
/* 
 * How close we want to hit the 
 * boundary value with a shot
 */
#define TOLERANCE 1.0E-6
typedef double vector[2];

/* 
 * FOLLOWING ARE THE FUNCTIONS TO 
 * CALCULATE THE FIRST VECTOR DERIVATIVE 
 * REQUIRED FOR A FOURTH-ORDER
 * RUNGE-KUTTA SOLUTION.
 *
 * In the following function, "x" replaces
 * "psi" and "x1" replaces "phi" in the
 * article text; "t" replaces "x" in the
 * article text.  "energyE" replaces "E"
 * and "energyA" replaces "A" in the 
 * article text.  
 */
void sysf1(double t, 
 double *x, double *x1)
{
 x1[0] = x[1];
 x1[1] = (t <= 0.0) ? -energyE*x[0] : 
 (energyA - energyE)*x[0];
}

/* 
 * FOLLOWING IS THE FOURTH-ORDER 
 * RUNGE-KUTTA METHOD FOR A SYSTEM
 * OF FIRST-ORDER ORDINARY DIFFERENTIAL
 * EQUATIONS
 */
  
void sysRK4(double t, double h, double *x, 
 int size)
/* 
 * This function returns the state of
 * the system x at t+h, given the state
 * of the system x at t.  As above,
 * "x" replaces "psi" and "t" replaces
 * "x" in the article text.  The 
 * parameter "size" tells how many
 * equations in the system of 
 * equations.
 */
{
 vector y, x0, x1, x2, x3, x4;
 int i;
 
 /* get the RK functions first */
 for (i = 0; i < size; i++) 
 x0[i] = x[i];
 sysf1(t, x0, x1);
 for (i = 0; i < size; i++) 
 x0[i] += h * x1[i]/2;
 sysf1(t+h/2, x0, x2);
 for (i = 0; i < size; i++) 
 x0[i] += h * (x2[i] - x1[i])/2;
 sysf1(t+h/2, x0, x3);
 for (i = 0; i < size; i++) 
 x0[i] += h * (x3[i] - x2[i]/2);
 sysf1(t+h, x0, x4);
 
 /* now step forward by h */
 for (i = 0; i < size; i++)
 y[i] = x[i] + 
 h * (x1[i] + 2*x2[i] + 
   2*x3[i] + x4[i])/6;
 for (i = 0; i < size; i++) x[i] = y[i];
}

/* THE FOLLOWING FUNCTION PERFORMS ALL
 * OFFSCREEN DRAWING AND MOVIE-MAKING
 * FOR THE SEARCH FOR AND VISUALIZATION
 * OF THE FIRST FIVE EIGENVALUES AND
 * EIGENFUNCTIONS OF THE PARTICLE IN A
 * BOX PROBLEM.
 */
void shoot5Waves(void)
{
 int nint = 128, i, k, ntrial, nroots;
 double a = -1.0, b = 1.0, h, t, 
 step = 0.25, v, s = 0.0;
 double beta = 0.0, beta1, beta2, 
 z1 = 1.0;
 vector x;
 long   dontCare;
 GWorldPtr  oldGWorld;
 GDHandle   oldGDev;
 Handle mySound;
 short  neededFrames, nFrames;
 /* GLOSSARY
  * nint: number of intervals in Runge-
  *   Kutta shot
  * i, k: loop indices
  * ntrial: number of trials to find
  *   five energy eigenvalues 
  * nroots: number of solutions found
  * a, b: left and right boundary
  * h: size of Runge-Kutta interval
  * t: replaces "x" in article text;
  *   the independent variable
  * step: step between trials of 
  *   energy in search for energy
  *   eigenvalue
  * v: trial value of energy
  * s: initial value for "psi" at x=a
  * beta: goal for boundary value
  * beta1, beta2: results of two 
  *   successive shots in attempt to
  *   hit boundary value
  * z1: presumed slope of function at
  *   left boundary
  * x: result of one Runge-Kutta step
  * mySound: Handle to a sound resource
  * neededFrames: how many extra frames
  *   we need at end
  * nFrames: loop index
  */
 
 /* 
  * Set up 2D graphics in our offscreen 
  * rectangle 
  */
 view_window(-1.0, -0.8, 1.0, 0.8);
 /* 
  * -1.0 <= x <= 1.0; 
  * -0.8 <= psi <= 0.8
  */ 
 view_port(offRect.left, offRect.bottom, 
 offRect.right, offRect.top);
 
 /* 
  * Set up two off-screen bitmaps; 
  * one will contain the permanent 
  * contents of the onscreen window; 
  * the other will contain an individual 
  * "shot" at the function.
  */

 ntrial = 1;
 nroots = 0;
 
 /* erase the "results" box */
 tempRect = HotRect_EVals;
 InsetRect(&tempRect, 1, 1);
 EraseRect(&tempRect);
 
 /* 
  * Draw the initial background; 
  * see Figure 4 in article. 
  */ 
 GetGWorld(&oldGWorld, &oldGDev);
 SetGWorld(offPort1, NULL);
 LockPixels(offPort1->portPixMap);
 EraseRect(&offRect);
 RGBForeColor(&bkgdColor);
 FillRect(&offRect, black); 
 RGBForeColor(&Black_ForeColor);   
 /* draw axes */
 MoveTo(100, 0);
 LineTo (100, 199);
 MoveTo(0, 100);
 LineTo (199, 100);
 FrameRect(&offRect);
 UnlockPixels(offPort1->portPixMap);
 SetGWorld(oldGWorld, oldGDev);
 
 do /* until we get five solutions */ 
 {
 h = (b - a)/nint;
 t = a;
 x[0] = s;
 x[1] = z1;
 
 v = ntrial * step;
 energyE = v;
 /* post this value in window */
 TextSize(9);
 sprintf((char *)sTemp, "%.3f", 
 energyE);
 tempRect = HotRect_RectE;
 InsetRect(&tempRect, 1, 1);
 TextBox((Ptr)&sTemp, strlen(sTemp), 
 &tempRect, teJustLeft);
 
 /* 
  * Take  Runge-Kutta steps; 
  * at each step, draw function in 
  * offscreen world #2 
  */
 GetGWorld(&oldGWorld, &oldGDev);
 SetGWorld(offPort2, NULL);
 LockPixels(offPort2->portPixMap);
 EraseRect(&offRect);
 /* NOTE: the functions wMoveTo and
  * wLineTo move and draw in the 
  * "real world"; by means of the
    * windowing transformation, they
    * are transformed to appropriate
  * QuickDraw MoveTo and LineTo calls
  * in pixels in offscreen world #2
  */
 wMoveTo(-1.0, 0.0);
 for (k = 1; k < nint; k++)
 {
 sysRK4(t, h, x, 2);
 t += h;
 wLineTo(t, x[0]);
 }
 UnlockPixels(offPort2->portPixMap);
 SetGWorld(oldGWorld, oldGDev);
 
 /*
  * Copy background from offscreen 
  * port #1 to offscreen port #2
  */
 CopyBits(&offPort1->portPixMap, 
 &offPort2->portPixMap,  
 &offRect, &offRect, srcOr, NULL);
 /* 
  * Copy picture from off screen port 
  * #2 to onscreen port
  */
 CopyBits(&offPort2->portPixMap, 
 &(WPtr_Particle_in_a_B->portBits),  
 &offRect, &HotRect_RectPsi, 
 srcCopy, NULL);

 /* 
  * Look for solution:  beta1
  * (last hit of shot on right
  * boundary) and beta2 (this
  * hit of shot on right
  * boundary) are opposite in
  * sign; this indicates that
  * in between a shot must have
  * hit the boundary value 0.
  */
 switch (ntrial)
 {
 case 1 :  beta1 = x[0];
   break;
 case 2 :  beta2 = x[0];
       break;
 default : beta1 = beta2;
   beta2 = x[0];
   break; 
 }
 
 if (beta1*beta2 < 0.0)
 {
 nroots++;
 /* 
  * Quick interpolation for energy
  * eigenvalue 
  */
 energyE = 
 v + step*beta2/(beta1-beta2);
 /* put result in window */
 sprintf((char *)sTemp, 
 "#%d at %7.3lf", nroots, 
 energyE);
 CtoPstr((char *)sTemp);
 MoveTo(HotRect_EVals.left+2, 
 HotRect_EVals.top+(nroots*12));
 TextSize(9);
 DrawString(sTemp);
 /* 
  * Draw this function into the 
  * offscreen bitmap #1 
  * permanently, so that it
  * becomes part of the 
  * background.
  */
 GetGWorld(&oldGWorld, &oldGDev);
 SetGWorld(offPort1, NULL);
 LockPixels(offPort2->portPixMap);
 /*
  * As a visual cue, if the
  * energy eigenvalue is allowed, 
  * draw the eigenfunction in 
  * green; if forbidden, in red.
  */
 if (energyE < energyA)
 RGBForeColor(&forbidColor);
 else
 RGBForeColor(&allowColor);
 /* Same as drawing a "shot" */  
 wMoveTo(-1.0, 0.0);
 h = (b - a)/nint;
 t = a;
 x[0] = s;
 x[1] = z1;
 for (k = 1; k < nint; k++)
 {
 sysRK4(t, h, x, 2);
 t += h;
 wLineTo(t, x[0]);
 }
 RGBForeColor(&Black_ForeColor);
 UnlockPixels(
 offPort2->portPixMap);
 SetGWorld(oldGWorld, oldGDev);
 /* 
  * As an audible cue, 
  * play the sound; I picked
  * a system sound resource
  */
 mySound = GetResource('snd ', 6);
 SndPlay(NIL, mySound, FALSE);
 }
 ntrial++;
 
 /* 
  * HERE, IF WE ARE MAKING A MOVIE, 
  * WE MAKE A FRAME.
  * THIS IS COPIED FROM 
  * QUICKTIME DEVELOPER'S KIT.
  *
  * The idea is to copy what's
  * on screen right now to a
  * movie frame.
  */
 if (makingMovie)
 {
 GetGWorld(&oldGWorld, 
 &oldGDevice);
 SetGWorld(myGWorld, nil);
 EraseRect(&offGRect);
 CopyBits(
 &(WPtr_Particle_in_a_B->portBits),
 (BitMap *)pm,
 &(WPtr_Particle_in_a_B->portRect),
 &offGRect,
 srcCopy, NULL);
 
 /* compress the frame */
 ErrorCode = 
 CompressSequenceFrame(seqID, 
 &pm, &offGRect,
 codecFlagUpdatePrevious,
 StripAddress(
 *compressedFrameBitsH),
 &compressedFrameSize, 
 &similarity, nil);
 if (ErrorCode) 
 DebugStr((StringPtr)
 "\pCompressSequenceFrame Failed");
 
 /* add it to the media */
 ErrorCode = 
 AddMediaSample(gMedia, 
 compressedFrameBitsH,
 0L, compressedFrameSize, 
 (TimeValue)1,
 (SampleDescriptionHandle) 
 imageDescriptionH, 1L,
 similarity ? 
 mediaSampleNotSync : 0, 
 &sampTime);
 if (ErrorCode)
 DebugStr((StringPtr)
 "\pAddMediaSample Failed");
 SetGWorld(oldGWorld, oldGDevice);
 }

 } while (nroots < 5);
 
 /* 
  * Remove the last black curve at the 
  * end 
  */
 GetGWorld(&oldGWorld, &oldGDev);
 SetGWorld(offPort2, NULL);
 LockPixels(offPort2->portPixMap);
 EraseRect(&offRect);
 SetGWorld(oldGWorld, oldGDev);
 CopyBits(&offPort1->portPixMap, 
 &offPort2->portPixMap,  
 &offRect, &offRect, srcOr, NULL);
 CopyBits(&offPort2->portPixMap, 
 &(WPtr_Particle_in_a_B->portBits),  
 &offRect, &HotRect_RectPsi, srcCopy, 
 NULL);
 if (makingMovie)
 {
 GetGWorld(&oldGWorld, &oldGDevice);
 SetGWorld(myGWorld, nil);
 EraseRect(&offGRect);
 CopyBits(
 &(WPtr_Particle_in_a_B->portBits),
 (BitMap *)pm,
 &(WPtr_Particle_in_a_B->portRect),
 &offGRect,
 srcCopy, NULL);
 
 /* compress the frame */
 ErrorCode = 
 CompressSequenceFrame(seqID, &pm, 
 &offGRect,
 codecFlagUpdatePrevious, 
 StripAddress(
 *compressedFrameBitsH),
 &compressedFrameSize, 
 &similarity, nil);
 if (ErrorCode) 
 DebugStr((StringPtr)
 "\pCompressSequenceFrame 
 Failed");
 
 /* 
  * Add it to the media enough for 
  * "trailerTime" secs 
       */
 neededFrames = 
 trailerTime*myTimeScale;
 nFrames = 0;
 do
 {
 ErrorCode = 
 AddMediaSample(gMedia, 
 compressedFrameBitsH,
 0L, compressedFrameSize, 
 (TimeValue)1,
 (SampleDescriptionHandle) 
 imageDescriptionH, 1L,
 similarity ? 
 mediaSampleNotSync : 0,
 &sampTime);
 if (ErrorCode)
 DebugStr((StringPtr)
 "\pAddMediaSample Failed");
 } while (nFrames++ < neededFrames);
 SetGWorld(oldGWorld, oldGDevice);
 }
 
 readyToRun = FALSE;
 if (makingMovie)
 {
 Close_The_Output_File();
 makingMovie = FALSE;
 }
 TextSize(12);
}

/* THIS FUNCTION CONSTRUCTS THE TWO
 * OFFSCREEN GWORLDS REQUIRED BY THE
 * SHOOT5WAVES FUNCTION.  IT IS CALLED
 * ONLY ONCE, AFTER THE WINDOW IS OPEN
 */
void buildBitMap()
{
 GDHandle currDev;
 CGrafPtr currPort;
 QDErr  myGoof;
 
 /* 
  * Builds two BitMaps which match the 
  * "wave function" rectangle pixels; 
    * establishes offscreen GWorlds.
  * Borrowed from "Braving Offscreen 
  * Worlds," G. Ortiz, develop, 
  * Jan 90, pg 28. 
  */
 GetGWorld(&currPort, &currDev);
 
 SetRect(&offRect, 0, 0, 
 HotRect_RectPsi.right - 
 HotRect_RectPsi.left,
 HotRect_RectPsi.bottom - 
 HotRect_RectPsi.top);
 myGoof = NewGWorld(&offPort1, 8, 
 &offRect, NULL, NULL, 
 (GWorldFlags)0); 
 /* 
  * If we didn't goof, we've got an 
  * offscreen world */
 if (!myGoof) 
 {
 SetGWorld(offPort1, NULL);
 LockPixels(offPort1->portPixMap);
 EraseRect(&offRect);
 /* 
  * Fill rectangle with background 
  * color
  */
 RGBForeColor(&bkgdColor);
 FillRect(&offRect, black); 
 RGBForeColor(&Black_ForeColor);   
 /* Draw axes on background */
 MoveTo(100, 0);
 LineTo (100, 199);
 MoveTo(0, 100);
 LineTo (199, 100);
 FrameRect(&offRect);
 UnlockPixels(offPort1->portPixMap);
 }
 else 
 {
 /* not much of a warning! */
 SysBeep(10);
 }
 
 /* do it again for GWorld #2 */
 myGoof = NewGWorld(&offPort2, 8, 
 &offRect, NULL, NULL,    
 (GWorldFlags)0); 
 if (!myGoof) 
 {
 SetGWorld(offPort2, NULL);
 LockPixels(offPort2->portPixMap);
 EraseRect(&offRect);
 UnlockPixels(offPort2->portPixMap);
 }
 else 
 {
 SysBeep(10);
 }
 SetGWorld(currPort, currDev);
}

Bibliography

Anderson, Jay Martin. Introduction to Quantum Chemistry. (New York: W.A. Benjamin, 1969). In the author’s own quantum mechanics textbook, he introduces the particle in a box with a barrier on pg. 57.

Apple Computer. QuickTime Developer’s Guide. (Cupertino: Apple Computer, 1991). In version 1.0 of the Guide, the examples relevant to this article begin on page 2-40. The Guide also comes with a CD-ROM with many code examples.

Cheney, Ward, and Kincaid, David. Numerical Mathematics and Computing. (Pacific Grove, California: Brooks/Cole Publishing Co., 1985). These authors discuss the Runge-Kutta method on pages 311 and 390, and the shooting method beginning on page 411.

Mark, Dave. Macintosh C Programming Primer. Volume II. (Reading, Mass.: Addison-Wesley Publishing Co., 1990). See offscreen drawing and GWorlds beginning on page 202.

Ortiz, Guillermo, “Braving Offscreen Worlds,” develop, #1, January 1990, page 28.

Ortiz, Guillermo, “QuickTime 1.0: ‘You Oughta be in Pictures’,” develop, #7, Summer 1991, page 7.

Othmer, Konstantin, “QuickDraw’s CopyBits Procedure: Better than Ever in System 7.0,” develop, #6, Spring 1991, page 23.

Press, William H., et al. Numerical Recipes in C: The Art of Scientific Programming. (New York: Cambridge University Press, 1988). In this compendium of numerical algorithms, you’ll find the Runge-Kutta method on page 569 and the shooting method on page 602; the book comes with a diskette with useful code examples as well.

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

Together 3.6.1 - Store and organize all...
Together helps you organize your Mac, giving you the ability to store, edit and preview your files in a single clean, uncluttered interface. Features Smart storage. With simple drag-and-drop... Read more
Cloud 4.1.1 - File sharing from your men...
Cloud is simple file sharing for the Mac. Drag a file from your Mac to the CloudApp icon in the menubar and we take care of the rest. A link to the file will automatically be copied to your clipboard... Read more
OmniFocus 2.7.1 - GTD task manager with...
OmniFocus helps you manage your tasks the way that you want, freeing you to focus your attention on the things that matter to you most. Capturing tasks and ideas is always a keyboard shortcut away in... Read more
CleanApp 5.1.1 - Application deinstaller...
CleanApp is an application deinstaller and archiver.... Your hard drive gets fuller day by day, but do you know why? CleanApp 5 provides you with insights how to reclaim disk space. There are... Read more
ForkLift 3.0 Beta 2 - Powerful file mana...
ForkLift is a powerful file manager and ferociously fast FTP client clothed in a clean and versatile UI that offers the combination of absolute simplicity and raw power expected from a well-executed... Read more
Sublime Text 3126 - Sophisticated text e...
Sublime Text is a sophisticated text editor for code, markup, and prose. You'll love the slick user interface, extraordinary features, and amazing performance. Features Goto Anything. Use Goto... Read more
1Password 6.3.3 - Powerful password mana...
1Password is a password manager that uniquely brings you both security and convenience. It is the only program that provides anti-phishing protection and goes beyond password management by adding Web... Read more
WhatsApp 0.2.1880 - Desktop client for W...
WhatsApp is the desktop client for WhatsApp Messenger, a cross-platform mobile messaging app which allows you to exchange messages without having to pay for SMS. WhatsApp Messenger is available for... Read more
NeoFinder 6.9.3 - Catalog your external...
NeoFinder (formerly CDFinder) rapidly organizes your data, either on external or internal disks, or any other volumes. It catalogs all your data, so you stay in control of your data archive or disk... Read more
Amadeus Pro 2.3.1 - Multitrack sound rec...
Amadeus Pro lets you use your Mac computer for any audio-related task, such as live audio recording, digitizing tapes and records, converting between a variety of sound formats, etc. Thanks to its... Read more

Paperback: The Game (Games)
Paperback: The Game 1.0 Device: iOS Universal Category: Games Price: $3.99, Version: 1.0 (iTunes) Description: You are an author trying to finish kitschy paperback novels. Complete Westerns, Science Fiction, Romance or even a Crime... | Read more »
How to Rule With a Firm Hand in My Majes...
My Majesty is a kingdom management sim not unlike August’s magisterial hit, Reigns. It’s essentially a reskin of developer Tigrido’s previous management sim, Dictator. As supreme ruler of the land, you must consult with a number of subjects to... | Read more »
Our 5 Favorite iMessage Sticker Packs
At long last, iMessage joins the ranks of messaging apps the likes of LINE and Whatsapp, adding an impressive collection of stickers. They’re a great way to add a little something extra to your daily conversations. [Read more] | Read more »
How to get past Vulture Island's tr...
Vulture Island is a colorful and quirky mish-mash of platforming and puzzles. It’s creative and fresh, but sometimes the game can throw a curveball at you, leaving you stuck as to how you should progress. These tips will help you explore smoothly... | Read more »
The new Clash of Kings is just for Weste...
If you’ve played the original Clash of Kings, you’ll probably recognise the city building, alliance forging and strategic battles in Clash of Kings: The West. What sets this version apart is that it’s tailor made for a Western audience and the... | Read more »
Frost - Survival card game (Games)
Frost - Survival card game 1.12.1 Device: iOS Universal Category: Games Price: $3.99, Version: 1.12.1 (iTunes) Description: *Warning: the game will work on iPhone 5C and above and iPad Pro / 4. Other devices are not supported* | Read more »
How to build and care for your team in D...
Before you hit the trail and become a dog sledding legend, there’s actually a fair bit of prep work to be done. In Dog Sled Saga, you’re not only racing, you’re also building and caring for a team of furry friends. There’s a lot to consider—... | Read more »
How to win every race in Dog Sled Saga
If I had to guess, I’d say Dog Sled Saga is the most adorable racing game on the App Store right now. It’s a dog sled racing sim full of adorable, loyal puppies. Just look at those fluffy little tails wagging. Behind that cute, pixelated facade is... | Read more »
Let the war games commence in Gunship Ba...
Buzz Lightyear famously said, “This isn’t flying, this is falling – with style!” In the case of Gunship Battle: Second War, though, this really is flying - with style! The flight simulator app from Joycity puts you in control of 20 faithfully... | Read more »
How to get a high score in Fired Up
Fired Up is Noodlecake Games’ high score chasing, firefighting adventure. You take control of a wayward firefighter who propels himself up the side of a highrise with blasts of water. Sound silly? It is. It’s also pretty difficult. You can’t... | Read more »

Price Scanner via MacPrices.net

15-inch 2.2GHz Retina MacBook Pro on sale for...
B&H Photo has the 2015 15″ 2.2GHz Retina MacBook Pro (MJLQ2LL/A) on sale for $1799, including free shipping plus NY sales tax only. Amazon also has the 2015 15″ 2.2GHz Retina MacBook Pro (... Read more
Toughbook Celebrates 20 Years of Ruggedized M...
Panasonic System Communications Company of North America, Division of Panasonic Corporation of North America (Panasonic) today celebrates the 20th anniversary of its industry-leading Toughbook mobile... Read more
12-inch 1.1GHz Gray Retina MacBook on sale fo...
B&H Photo has the 2016 12″ 1.1GHz Gray Retina MacBook on sale for $1199.99 including free shipping plus NY sales tax only. Their price is $100 off MSRP. Read more
13-inch 2.5GHz MacBook Pro (Apple refurbished...
Apple has Certified Refurbished 13″ 2.5GHz MacBook Pros available for $829, or $270 off the cost of new models. Apple’s one-year warranty is standard, and shipping is free: - 13″ 2.5GHz MacBook Pros... Read more
Save 30% on Camera Guard’s Secure Protection...
To celebrate the release of macOS Sierra, Miami-based security solutions company, ProtectStar has announced a special 30% discount on Camera Guard Professional for Mac 2016. This innovative security... Read more
DVDFab Special Deal – Get a 1-Year Free Licen...
Beijing, China based specialist in the field of DVD, Blu-ray and video backup solutions, Fengtao Software has launched its Autumn Special Deals 2016, giving a 1-year free license of a randomly picked... Read more
21-inch iMacs on sale for up to $120 off MSRP
B&H Photo has 21″ iMacs on sale for up to $120 off MSRP including free shipping plus NY sales tax only: - 21″ 3.1GHz iMac 4K: $1379 $120 off MSRP - 21″ 2.8GHz iMac: $1199.99 $100 off MSRP - 21″ 1... Read more
13-inch 2.7GHz/256GB Retina MacBook Pro on sa...
Amazon.com has the 13″ 2.7GHz/256GB Retina Apple MacBook Pro on sale for $151 off MSRP including free shipping: - 13″ 2.7GHz/256GB Retina MacBook Pro (sku MF840LL/A): $1348 $151 off MSRP Read more
Apple TVs on sale for up to $50 off MSRP
Best Buy has 32GB and 64GB Apple TVs on sale for $40-$50 off MSRP on their online store. Choose free shipping or free local store pickup (if available). Sale prices for online orders only, in-store... Read more
Apple refurbished 13-inch Retina MacBook Pros...
Apple has Certified Refurbished 13″ Retina MacBook Pros available for up to $270 off the cost of new models. An Apple one-year warranty is included with each model, and shipping is free: - 13″ 2.7GHz... Read more

Jobs Board

*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
Restaurant Manager (Neighborhood Captain) - A...
…in every aspect of daily operation. WHY YOU'LL LIKE IT: You'll be the Big Apple . You'll solve problems. You'll get to show your ability to handle the stress and Read more
Sr. *Apple* Mac Engineer - Net2Source Inc....
…staffing, training and technology. We have following position open with our client. Sr. Apple Mac Engineer6+ Months CTH Start date : 19th Sept Travelling Job If Read more
*Apple* Retail - Multiple Positions-Norfolk,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
Restaurant Manager (Neighborhood Captain) - A...
…in every aspect of daily operation. WHY YOU'LL LIKE IT: You'll be the Big Apple . You'll solve problems. You'll get to show your ability to handle the stress and Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.