CHARYBDIS
A Computer Simulation of Laser Cooling
Charybdis, poised opposite Scylla, was the terrifying
whirlpool which nearly ensnared Odysseus as he swept past it on his
way home to Ithaca after the Trojan war. It caught and engulfed
countless ships and sailors, drawing them down into the depths of the
ocean where they remained for eternity.
Overview of Charybdis
Charybdis is a program written to simulate the actions of laser
cooling upon a single 87Rb atom. In its current
incarnation, it is using then 780 nm line for abosorption. The atom is
injected into the containment system and tracked through its motions
as it absorbs and emits photons from the lasers.
In order to decrease computational time and difficulty,
Charybdis simulates the workings of optical molasses in a
simple two-dimensional system, rather than a three-dimensional one,
which would provide output considerably more useful in terms of
comparing it with experimental results. However, Charybdis offers
sufficient output to examine trends which offer insight into how laser cooling
works in the lab.
In order to write Charybdis, we assumed the following:
- A particle in the trap is only capable of absorbing a single photon at
a time.
- Photon absorption conserves momentum but not necessarily kinetic
energy.
- The lasers used in optical molasses are all set at a single fixed
frequency.
We also made the following decisions and assumptions in actually
writing the program:
- Only one particle would be injected into the trap at a time. This
was done to increase efficiency. We assumed that the system would be
at the dilute limit, so we only simulated one atom per run.
- Since only one particle was injected into the trap, there would be
no possibility of interparticle collision or of masking.
- We assumed that a quartet of 5-watt lasers was used to set up the
trap. (Of course, in the lab six lasers would be necessary,
but for our simulation a two-dimensional system was constructed.)
- The emission of a photon from the excited atom is in a random
direction.
Workings of Charybdis
Charybdis is a fairly simple simulator of a single particle in
a laser-cooling trap. The bulk of the program consists of a loop
which performs the following actions:
- Determination of photon absorbed
- Movement of the particle and update of time
counter
- Absorption of a photon, modification of
particle energy, and determination of time until emission
- Movement of the particle and update of time
counter
- Emission of the photon and modification of
particle energy
1. Determination of photon absorbed
Charybdis begins each loop by calculating the
relativistic doppler shift
for each laser based upon the particle velocity. Once the
doppler-shifted frequencies for each laser have been calculated, the
probability
of absorbing a single photon (assuming a collision) from each laser is
calculated. Finally, these probabilities are used to compute an
exponential-decay random number which is the time until a photon is
absorbed from each laser.
These four times are then compared. The laser associated with the
lowest time is considered the laser from which the absorbed photon
will emanate, thus determining the direction and frequency (and
therefore momentum) of the absorbed photon. The time until this
photon is absorbed is considered to be the amount of time the particle
travels until its momentum and energy are altered.
2. Movement of the particle and update of time counter
Once the time the particle moves has been calculated, the movement of
the particle is determined. The x- and y- velocities of the particle
are simply multiplied by this time to determine the displacement
of the particle from its position at the beginning of the loop. The
time counter, a variable which keeps track of the amount of time
elapsed since the particle was injected into the trap, is incremented
by this amount of time.
3. Absorption of a photon, modification of particle
energy, and determination of time until emission
The momentum of the photon being absorbed is calculated from the
frequency of the particle (determined in Section
1). As the photon is absorbed, the particle's velocity is
modified through the equations describing conservation of momentum.
The kinetic energy of the particle is then recalculated based upon its
new velocity.
Since the
lifetime of the excited state
depends upon the particle used (Charybdis at the moment
simulates a 87Rb atom), the exponential-decay envelope
random number generator is used to calculate a time until the particle
returns to the ground state and a photon (of the same frequency as the
absorbed photon) will be emitted.
4. Movement of the particle and update of time counter
This section of the code functions exactly as Section
2.
5. Emission of the photon and modification of the
particle energy
The photon is assumed to be emitted in a random direction. The
uniform-distribution random number generator is used to determine an
angle between 0 and 2p. This angle is used
to determine the cartesian (x- and y-) components of the momentum of
the emitted photon. As in Section 3,
conservation of momentum is used to determine the particle's new
velocity; this new data is then used to recalculate the particle's
energy.
Random Number Generation
As with all simulation software which deals with nondeterministic
events, Charybdis depends heavily upon random number
generation. Of course, truly random number generation is not possible
with today's computers at the speeds at which the simulation software
requires it. As a result, pseudorandom number generators are
used. These programs output a series of numbers (in this case,
floating-point numbers) with an extremely long period.
The large number of cycles performed by Charybdis leads to a
requirement for a great many random numbers. Additionally, a random
number generator with very low overhead (i.e., one which takes very
little time to generate a pseudorandom number) was desired, to keep
computation time down.
In order to meet these requirements, a lagged-fibonacci generator
designed by Pryor et al. was used. This random number generator was
designed for use in parallel computing and Monte Carlo algorithms. As
a result, it possesses a very long period (on the order of
1060) as well as a minimal overhead (under 1 microsecond
per generation).
Two distribution envelopes were used in Charybdis: a
uniform distribution envelope and an exponential-decay distribution
envelope. The uniform distribution envelope generates a
floating-point number between 0 and 1 with equal probability for each
number. The exponential-decay envelope generates a floating-point
number between 0 and infinity, with the probability of the number
being generated dropping exponentially as the magnitude of the number
increases.
Source code for Charybdis
C source code for Charybdis is available to those who desire
it. We make this code freely available for those who wish to use it.
Note however that the random number generator is copyright Daniel
Pryor et al.
C source code for charybdis
Note that until the issue of distribution of the random number
generator is resolved, we are unfortunately unable to provide the
code. It will likely be available in the near future.
Acknowledgements
Charybdis would not have been possible without the work of
Michael Cope and Francis Carr, whose work on modifying the random
number generator used in the program was instrumental. This project
would also have been severely crippled had Pryor, et al not allowed us
to use their random number generator. Finally, we are indebted to
Peter Saeta for his assistance in the construction of the program. To
each of these people, we offer our thanks.
This page was made by
Jason
Fredrickson
·
Jamey Minnis
·
Itai Seggev