Simulated Rayleigh Scattering - Brigham Young University ...€¦ · Simulated Rayleigh Scattering...
Transcript of Simulated Rayleigh Scattering - Brigham Young University ...€¦ · Simulated Rayleigh Scattering...
Simulated Rayleigh Scattering
byJames Nelson
A senior thesis submitted to the faculty of
Brigham Young University - Idaho
in partial fulfillment of the requirements for the degree of
Bachelor of Science
Department of Physics
Brigham Young University - Idaho
July, 2015
BRIGHT YOUNG UNIVERSITY - IDAHO
DEPARTMENT APPROVAL
of a senior thesis submitted by
James Nelson
This thesis has been reviewed by the research committee, senior thesis coordinator, anddepartment chair and has been found to be satisfactory.
Date Todd Lines, Advisor
Date Evan Hansen, Committee Member
Date Kevin Kelley, Committee Member
Date Stephen McNeil, Department Chair
ABSTRACT
Simulated Rayleigh Scattering
James Nelson
Department of Physics
Bachelor of Science
A simulator was created, which makes use of Monte Carlo to model the behavior of scattered
electromagnetic radiation in a given medium. The program provides a flexible framework which
can be adapted to explore various scattering phenomena from a semi-classic macroscopic point
of view. Proper adaptation of the simulator does require some background knowledge of object-
oriented programming. The geometry of the test and the output produced must be configured by
the user. A test to simulate Rayleigh scattering, the most dominant type of scattering for visible
light in our atmosphere, was implemented and compared against actual measurement of skylight
both qualitatively and quantitatively. It was found that the generated data had the characteristics
of natural skylight.
Acknowledgements
Thank you to Todd Lines for giving me the idea for this project, in the first place, and giving
helpful feedback and insight through out it’s development. And thank you Matthew Brownell for
configuring the Romney cpu cluster and providing technical support.
Contents
1 Introduction 11.1 Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3 Introduction to Rayleigh Scattering . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.4 Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Methods 92.1 Monte Carlo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.2 System Requirements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.3 Simulator Conditions and Assumptions . . . . . . . . . . . . . . . . . . . . . . . . . . 102.4 Modeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.5 Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3 Results 153.1 Comparison with Skylight . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.2 Conclusions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273.3 Future Research . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
A Simulator Source Code 31
vii
List of Figures
1.1 Abstract diagram of the components of the simulator. . . . . . . . . . . . . . . . . . 21.2 Class hierarchy of the simulator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.3 This figure indicates a full hemisphere view of the direction and magnitude of polar-
ization induced by Rayleigh scattering, as viewed from an observer looking up withthe sun directly above them. Adapted from from [6]. . . . . . . . . . . . . . . . . . . 4
1.4 The top part of the figure shows the intensity of scattering for the isotropic events.The middle section shows the distribution created by the anisotropic events. EveryRayleigh scattering event falls into one of these two categroies. The last part showsthe two of them added together. Taken from [5]. . . . . . . . . . . . . . . . . . . . . 6
3.1 This is a full sky image taken by Dr Shaw in Manua Loa, Hawaii. Note the band ofstrongly polarized light. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2 This plot (provided by Dr. Shaw) shows Rayleigh scattering vs scattering angle (an-gle between original and scattered directions). Unpolarized light with a wavelengthof 650 nm, and particles with a 1 nm radius. . . . . . . . . . . . . . . . . . . . . . . 17
3.3 Angle from source vs angle of polarization (relative to the z-axis) . . . . . . . . . . . 173.4 Angle from source vs angle of incidence (relative to the z-axis) . . . . . . . . . . . . 183.5 Angle from source vs frequency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.6 Wavelength dependence of Rayleigh Scattering (adapted from Dr. Shaw) . . . . . . 203.7 Histogram of the number of detected scattered photons sorted by frequency. . . . . . 213.8 Frequency vs angle of polarization (from the Z-axis) . . . . . . . . . . . . . . . . . . 223.9 Frequency vs angle of incidence (from the Z-axis) . . . . . . . . . . . . . . . . . . . . 233.10 Angle from source vs relative polarization . . . . . . . . . . . . . . . . . . . . . . . . 243.11 Frequency vs Angle of Polarization (from the Z-axis) . . . . . . . . . . . . . . . . . . 253.12 Histogram showing the distribution of relative polarizations detected with an angle
of incidence of 45 degrees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
ix
Chapter 1
Introduction
1.1 Objective
The goal was to write a simulator that can accurately model the behavior of electromagnetic
radiation traveling through a medium. By implementing known details at the microscopic level,
such as calculation of the cross section and the probability distribution of the scattered photons that
could be produced, the model should produce distributions of data that have the same macroscopic
qualities and dependencies as physically observed in that type of scattering.
1.2 Overview
The program uses very generic and adaptable classes that can be useful in a wide variety of tests.
Then, more specific sub-classes were implemented to represent specific, known physical characteris-
tics. The end result of these sub-classes is a simulator that makes use of Monte Carlo to give results
that are statistically reliable, if run a sufficient number of times. The program allows the user to
specify the conditions and configuration of the test, as well as which resulting data is relevant to
include in the output. The simulator was used to model visible light as it passes through the air,
for the idealistic case of Rayleigh scattering only, and the generated results were validated against
actual measurement.
Figure 1.1 illustrates the basic idea behind the simulator. Photons are emitted from a source,
and after being scattered in a medium may or may not be absorbed by the detector. Each simulation
1
Figure 1.1: Abstract diagram of the components of the simulator.
must include the locations and dimensions of the source, medium, and detector class configured.
Every detected photon will be included in the output of the program. Photons that are not detected
will not be output.
A basic overview of the class structure is provided in figure 1.2. The detector, medium, and
source class are the generic parent classes for more specific implementations. Together with the
photon class, these make up the main components of a simulator implementation.
1.3 Introduction to Rayleigh Scattering
Rayleigh scattering occurs when incident photons interact with spherical or very nearly spherical
particles whose radius is much smaller that the wavelength of the incident light. This condition is
met in the case of visible light and the main components of our atmosphere (N2, O2, Ar, and CO2).
It also happens that visible light and radio waves are the only two ranges in the electromagnetic
2
Figure 1.2: Class hierarchy of the simulator.
spectrum where absorbance is greatly reduced and nearly all interactions result in a scattered
photon of the same energy (inelastic scattering) rather than converting some or all of that energy
into thermal motion of the air particles.
Rayleigh scattering was originally discovered and investigated by John William Strutt, the third
Lord of Rayleigh, in 1871. He correctly determined that this scattering is inversely proportional to
the wavelength raised to the fourth power. The equation to calculate the intensity of an unpolarized
beam of Rayleigh scattered light is
I =I0r2α2(
2π
λ)4
1 + cos2(θ)
2, (1.1)
where I0 is the original intensity, r is the distance traveled, α is a constant related to the po-
larizability of a particle, λ is the wavelength of the light, and θ is the azimuthal angle from the
original direction. In other words, the degree that Rayleigh scattering tends to affect light is highly
dependent on the wavelength of the light. This make the air somewhat like a big, fuzzy prism.
It also has a tendency to induce a partial polarization in completely unpolarized light. More
specifically, light scattered perpendicular to the beam will be strongly polarized in the azimuthal
direction compared to that beam as indicated in figure 1.4. That is how anti-glare lenses work.
3
Figure 1.3: This figure indicates a full hemisphere view of the direction and magnitude of polariza-tion induced by Rayleigh scattering, as viewed from an observer looking up with the sun directlyabove them. Adapted from from [6].
If the sun is directly above you, most of the light reflecting off the horizon from all directions in
vertically polarized. So a lens that filters vertically polarized light can remove most of the glare
without impeding visibility. Turn the lens 90 degrees and the glare comes back. Both [1] and [4]
give a more thorough treatment of polarization and the scattering of light.
In the context of visible light, Rayleigh scattering is the most dominant type of scattering in our
atmosphere. It is responsible for the blue hue that can be observed in the sky on a cloudless day.
This happens because photons with higher frequencies (green, blue, and purple) are exponentially
more likely to be scattered than lower frequency photons (such as red, orange, and yellow). If you
look in any direction other than directly at the sun, you are only seeing photons that have scattered
at least once and probably several times, and so the vast majority of them are these higher energy
photons that together appear blue. It is for this same reason that we observe red orange and yellow
shades at sunset or sunrise. At those angles, the atmosphere that the light must travel through
to reach an observer on the ground is much thicker. The higher frequency photons have scattered
so many times while traveling that they have become diffuse, and most of them scatter in some
4
direction other than that of the original beam. Lower frequency photons on the other hand, have
had a chance to scatter just the needed number times without being filtered out.
This phenomena is really the result of a pair of possible scattering events, both of which are
depicted in the figure . One type of event is completely isotropic. It does not affect the photon in
anyway, except to change its trajectory, and the transmitted photon has an even probability of going
in any direction. The other type of event is anisotropic, though it is still azimuthally symmetric
with respect to the original photon. This second type of event strongly favors forward and reverse
scattering, but still does not change the frequency or energy of the photon. The determining factor
between the two types is whether or not the orientation of the oscillation of the photon’s electric
field lies in the plane of scattering. When it does, the event will be anisotropic, and when it is
perpendicular to the plane of scattering the event will be isotropic. For further details see [5] and
[6].
Rayleigh scattering has a fairly strong effect on the physical measurement of skylight. These
effects can cause some degree of systematic error, especially in fields such as meteorology and
astronomy. If these effects can be properly accounted for, such systematic errors can be removed.
1.4 Applications
One of the simpler application of this model is the simulation of a solar eclipse. After configuring
the test for visible light through an atmosphere of sufficient size, simply remove all unscattered
light from the results. A lunar eclipse could be modeled in much the same way, after a lunar light
source is implemented. Given that these events are rare and short lived in any one location, it could
be useful to simulate them in advance in order to investigate what will be relevant to measure and
what you expect to find.
There are other radiation scattering scenarios that could benefit from such a model, such as
laser light or microwave radiation passing through a known medium. It should be noted however,
that fully quantum mechanical phenomena, such as interference through a diffraction grating, are
not present in this framework. It is intended that this program be utilized when macroscopic effects
5
Figure 1.4: The top part of the figure shows the intensity of scattering for the isotropic events. Themiddle section shows the distribution created by the anisotropic events. Every Rayleigh scatteringevent falls into one of these two categroies. The last part shows the two of them added together.Taken from [5].
6
are the focus of the tests. It should be feasible to extend this simulator to account for other types
of scattering, such as Mie or Compton.
7
Chapter 2
Methods
2.1 Monte Carlo
In a Monte Carlo test a simple situation is repeated numerous times in an attempt to draw con-
clusions or find relationships that would be arduous to calculate analytically. The analytic results,
whether known before hand or not, will be asymptotically approached with more and more itera-
tions of the test. A good example of this is found in the calculation of π. To use Monte Carlo to
calculate π, just take a squared circle, and start picking random points in the square. The ratio
of points inside and outside the circle can be used to estimate the value of π, and the greater the
number of points selected, the more closely this ratio will be to the exact value. An example of this
test is also included in this project, within the PiApproximation class. Monte Carlo is effective for
most highly repetitive processes, such as millions of photons traveling through an approximately
uniform medium.
2.2 System Requirements
All of the code in this simulator was written in C++. Some coding is required to configure the
test, so it is expected that the user have a working knowledge of C++. This simulator was run in
Centos 6. The output files were graphed using gnuplot, and the simulator does make use of the
9
gnu scientific library (GSL) both for scientific constants, and random number generation. Both of
these packages should be installed before the simulator can be compiled and run.
2.3 Simulator Conditions and Assumptions
This project consists of a simulator class which encapsulates everything else. The user is expected
to provide a main method which instantiates and configures this class. The simulator has a source,
through which all photons will be generated. The simulator also has a medium through which the
photons will scatter and a detector. The number of photons to generate and process must also be
set by the user. Note that this number represents the number of photons that will be generated,
not the number that will be captured by the detector. When run is called, a file name must be
specified to which to which all of the data will be sent. A good example of this can be found in the
ValidationSimulation.cpp file’s format method.
There are helper classes provided for matrix rotation in 3D space, and making histograms. The
output files were graphed using gnuplot, and the simulator does make use of the gnu scientific
library (GSL) both for scientific constants, and random number generation. In all cases SI units
were used to keep everything consistent. Also, the program calls for degrees over radians when
working with angles.
There are a number of random number generators (RNGs) offered in the GSL. The mt 19937
was the one used in this project. The documentation indicates that this implementation produces
numbers quickly, and that these numbers are uncorrelated. This feature was essential because
for each scattering event the simulator requires several independent random numbers. The other
important factor was that this random number generator has a very long period before repeating
numbers for any given seed. The calls to the RNG are in a singleton class, so switching implemen-
tations in the future would be practical. This implementation is located in the RandomSingleton
class.
Some of the 3D models were implemented as spheres in an effort to make them flexible and
intuitive. The medium class is a spherical cloud of whatever material is being represented. By
10
changing the size and configuration or even using multiple instances, many shapes can be approx-
imated. Detectors, too, are represented with the sub-surfaces of a sphere. Rectangular detectors
can be approximately represented by setting the angles of validation to be small and the radius to
be large.
2.4 Modeling
When implementing the photon class, it was appropriate to give a semi-classical treatment of
photons. The scenarios being modeled are assumed to be larger than a few centimeters. Photons
are assumed to travel in a straight Euclidean line at the speed of light. Therefore, there are
three coordinates associated with position and velocity (in Cartesian coordinates). The three
coordinates associated with velocity allow the user to indicate the direction. The normalization of
these coordinates is not important, only the direction indicated by their relative magnitude. Each
instance of the photon class also has a frequency, from which wavelength and energy are calculated.
There is an orientation variable for keeping track of the direction of the electric oscillation. Circular
polarization is also represented, but only as being clockwise, counter-clockwise, or not present, which
is the default. Each photon also has three coordinates associated with its point of origin.
Sources are modeled as being points from which photons are generated. Valid angles for emission
can easily be set, as well valid ranges of frequencies. The distribution of these quantities will be
uniform unless additional implementation is provided in a subclass written by the user.
As mentioned above, detectors are spherical sub-surfaces with a center position, a radius, a full
angle phi, and a half angle theta (spherical coordinates) that defines what portion of the surface
will detect photons. Currently the detectors are ideal, meaning that incident radiation has a 100%
chance of being absorbed and detected. Future work could be done to make models that showed
special sensitivity to certain frequencies or angles of incidence.
The medium class has a position, and a radius. It also has functions for calculating the free
path distance a given photon will travel through the material before a scattering event. There is
a similar function for calculating the free time a photon will travel between scattering events for
11
added flexibility. It is in the subclasses of the medium class where code to calculate the cross-section
for scattering or characteristics of the resulting photon should live, as explained below.
The Rayleigh class has the logic for the individual scattering events. As explained in [3] the
mechanism that determines whether a scattering event is isotropic is the difference between the
orientation of the electric oscillation and the plane of scattering. When these quantities are per-
pendicular the event will be isotropic, and when they are parallel the event will be anisotropic.
At all angles in between there are components in both directions and proportional chances of each
occurrence. It should be noted that the angle of scattering requires an inverse trigonometric func-
tion; otherwise the density of selected directions will be higher at the poles than in the azimuthal
directions. To achieve the correct distribution for the anisotropic case it is necessary to first apply
a normalization function that favors forward and reverse scattering before applying this correction.
The Atmosphere class is a subclass of the Rayleigh class which further specifies how the cross
section to interaction is to be found. To be useful, the free distance (or time) a photon travels
should not be uniform. In the case of Rayleigh scattering (and several other types) it should be
a Boltzmann distribution based on the cross section of interaction. Calculating the cross section
of electromagnetic radiation through different materials is an involved process, and techniques will
vary in each case. One method of calculation for visible light through air has been detailed in [2].
The article explains that given the index of refraction, the King factor of each gas (which is a term
related to calculating depolarization), and a few polynomial approximations, the cross section can
be found. By treating each of the four most common gasses in air as partial pressures with their
own distributions, four separate values are generated for the free distance from four distributions.
The shortest one is selected, and the others discarded.
The simulator class holds everything together. It has a source, a medium, a detector, and
a given number of times to generate a photon. Logic is provided to check for detection before,
during, and after the photon traverses the medium, thus giving more freedom to the user to use
any configuration they wish. There is also a check to discard any photon that leaves the medium on
a trajectory that does not go toward the detector. A test then consists of calling the main method,
which configures the members of the simulator, instantiates it, and runs it the specified number of
12
times with a given output file. All detected photons are sent to the format function, and their data
is sent to the output file.
2.5 Instructions
In order to utilize this framework, it will probably be necessary to subclass some of these general
implementations and a thorough example of how to do that is provided in the SimulateAtmosphere
program. In order to validate the model a uniform unpolarized visible light source was written, as
well as a detailed Atmosphere class that inherited some scattering logic from the Rayleigh class.
The simulator has visible light emitted toward an atmospheric medium with a radius of 100 km
toward a large detector.
If a photon is detected, the format function is called, and there is a default implementation to
send all of the data that is present in a photon after the last scattering event to the output file.
In most cases the user will want to specify what data to send to the file and in what order. In
many cases the user will also want to do some pre-processing on the data at this stage, since the
pertinent details will vary widely in each case (such as calculating the difference between a photon’s
orientation and its angle of incidence and outputting that value instead). This specification is
achieved by overriding the format function of the Simulator class to provide the relevant data in
the desired format. The scope of this function has access to all members of the Simulator class as
well as all values stored within the photon instance. In the atmosphere simulation example, data
is formatted according to frequency, various angles, degrees of polarization, and additional data is
stored in histograms to be sent to other output files later. These histograms are just objects of the
Histogram class that bin data in an array to show frequency. Check the SimulateAtmosphere class
in Appendix A for the actual implementation.
Running a simulation of only a million photons took only a few minutes, but in order to have
confidence in the results of any Monte Carlo simulator, it should run a very large number of times
(1,000,000 times should probably be considered a minimum for most cases). The simulator will
periodically indicate what percent it is toward completion, but it may still be desirable to run the
13
program as a background process for longer tests.
To run the Simulate Atmosphere program, find the directory that contains the executable in a
terminal, and type ./SimulateAtmosphere.out <number of photons to generate> <name of
test>. The main output file will be <name of test>-<host name of the computer>.out. There
will also be <name of test>-<host name of the computer>-f.out and <name of test>-<host
name of the computer>-p.out files containing histograms of the frequencies and polarizations
respectively. This means you can start the program on multiple machines using mpi or a script and
not worry about them writing to the same file. You also do not have to worry about them having
duplicate seeds, as each execution gets reseeded in the main method based on the time stamp and
the host name.
14
Chapter 3
Results
3.1 Comparison with Skylight
Dr. Joseph A. Shaw is a professor at Montana State University. He has spent many years measuring
and analyzing skylight. His findings have provided good data about the specifics of both skylight
in general and Rayleigh scattering specifically that can be used to verify the model, as found in
[7]. There are two key traits that a Rayleigh scattering model must have for skylight. First, blue
(higher frequency) light must scatter more readily and at wider angles than red (lower frequency)
light. For all unscattered photons detected, blue should be more abundant at all angles of incidence
and especially so as we approach 90 degrees. Second, Dr. Shaw references this equation,
DOLP =Ls − Lp
Ls + Lp=
1− cos2(θ)1 + cos2(θ)
=sin2(θ)
1 + cos2(θ), (3.1)
which can be used to calculate the degree of polarization of the scattered light as a function of
angle of incidence. According to equation 3.1 the scattered light should tend to be polarized in the
azimuthal direction, reaching a maximum of 100% at 90 degrees, and 33.3% at 45 degrees (which
was the condition this model checked for). Real skylight does not quite reach 100% polarization at
90 degrees of incidence because other types of scattering are present, but it does come fairly close.
Figure 3.1 shows an image taken from a cloudless sky in Hawaii. Additional explanation is found
15
Figure 3.1: This is a full sky image taken by Dr Shaw in Manua Loa, Hawaii. Note the band ofstrongly polarized light.
in [7].
Figure 3.2 shows the intensity of scattering at different angles of incidence (Shaw). Note that
the vertical axis is logarithmic. Figure 3.3 really serves two purposes. It shows that the scattering
is truly azimuthal. It also highlights the angles at which the photons tend to be detected with this
geometry.
The configuration used was effective for angles of incidence up to about 50 degrees. Much of
the data beyond that point affected by the geometry of the detector. Observe the square boundary
in figure 3.4. We can see this square pattern in the second plot at about the 50 degree mark.
The graph in figure 3.5 shows the correlations of frequency with angle of approach relative to
an unscattered beam from the source to the point on the detector where the photon made contact.
The solid line on the left side represents all of the photons in the test that did not scatter. Note also
how the number of scattered photons and the angle from source increase with frequency. Higher
frequency photons are considerably more likely to scatter more frequently and at wider angles, just
as we would expect. Compare with this diagram provided by Dr. Shaw in figure 3.6.
The number of scattered photons detected at 45 degrees were grouped by frequency in a his-
16
Figure 3.2: This plot (provided by Dr. Shaw) shows Rayleigh scattering vs scattering angle (anglebetween original and scattered directions). Unpolarized light with a wavelength of 650 nm, andparticles with a 1 nm radius.
Figure 3.3: Angle from source vs angle of polarization (relative to the z-axis)
17
Figure 3.6: Wavelength dependence of Rayleigh Scattering (adapted from Dr. Shaw)
togram (figure 3.7). Photons with a higher frequency were much more likely to be detected with
a higher degree of incidence and have a higher degree of polarization in the azimuthal direction. I
believe that the drop on the right side of the graph is because of the volume and constant density of
the medium. When light travels through more atmosphere, the highest frequency light starts to get
filtered out. It may also be another manifestation of the geometry of the test. The photons with
the very highest degrees of scattering dont get detected, and these are made up almost entirely of
higher frequency photons.
The plots in figures 3.8, and 3.9, show the number of photons detected by frequency for relative
polarization and angle of incidence respectively. The main difference is that the second plot groups
all unscattered photons in the band at the bottom. So, with the unscattered band, more low
frequency photons were detected, but without it mostly high frequency photons were detected. We
can therefore infer that the medium appears blue from the perspective of the detector and also at
all other angles since blue light is what is escaping from the system.
Figure 3.10 clearly demonstrates a tendency of the photons to be polarized perpendicularly to
20
Figure 3.10: Angle from source vs relative polarization
their angle of approach to the detector at all valid test angles. There are two clouds of photons at
the 90 and 270 degree mark, and relatively lower densities of detected photons at 0 (and 360) and
180 degrees.
Again we can observe the distinct correlation of polarization and azimuthal angle of approach
in this generated plot. The two diagonal bands in figure 3.11 show that as you alter the direction
of approach for the incident photon, there are maximal distributions of photons whose polarization
is perpendicular to that direction and minimal distributions that are aligned or anti-aligned with
it.
Lastly the histogram in figure 3.12 was for the detected photons with an angle of incidence
of 45 degrees. It shows a clearer picture of these bands, and was used to estimate the degree of
24
Figure 3.12: Histogram showing the distribution of relative polarizations detected with an angle ofincidence of 45 degrees.
polarization. We expect that the degree of polarization will increase from 0 to 90 degrees. We can
use this data to infer the degree of polarization. The area under curve at angles with a positive
bias minus the area under the angles with a negative bias divided by the total area is roughly equal
to
P =(220 photons ∗ 180 degrees)− (110 photons ∗ 180 degrees)
(220 photons + 110 photons) ∗ 180 degrees)= 33.3%. (3.2)
This is the degree of polarization predicted by by equation 3.1 for 45 degrees of incidence.
26
3.2 Conclusions
We can clearly observe the first macroscopic characteristic we were looking for. As the wavelength
of an incident beam increases, it becomes less likely to scatter by that same amount raised to
the fourth power. And indeed, our results show a line very similar to the one provided by Dr.
Shaw up to about 700 THz (remember that the generated graph is reversed since the x axis in
frequency rather than wavelength). If the test were run again with a thinner atmosphere perhaps
the correlation would be even stronger. The correlation of wavelength and intensity of scattering is
affected by the change in the magnitude of the cross section rather than being inherent in any given
scattering event. In other words, the scatter function in the file Rayleigh.cpp affects all photons
the same, regardless of their frequency (or wavelength). The getFreeDistance function on the other
hand, gives much lower values for photons with higher frequency because the cross section used to
calculate this distance is highly frequency dependent.
It is actually the selection mechanism for isotropic scattering in individual events that causes
the azimuthal polarization pattern. At no point in the code do we cause a biased change to a
photon’s polarization. In the Rayleigh class the scattering function does selectively change the
linear polarization on a photon, but only by giving it a new evenly distributed random value. In
earlier iterations of this model various biased changes were tested, but the results always tended
to yield either too much or the wrong kind of linear polarization. By randomly changing the
orientation of a photon for anisotropic scattering and leaving unchanged for isotropic scattering, a
very close match to the predicted degree of linear polarization at 45 degrees of incidence is achieved,
and that polarization is in exactly the right direction.
3.3 Future Research
This framework can be used to estimate the effects of Rayleigh scattering for other radiation related
projects. If the distribution of generated light and the variable density of the atmosphere were added
then a simulation could be made to give quantitative measurements of the sky, such as what is
the exact color we see when the sun reaches a certain angle above the horizon. If the type and
27
thickness of the medium are known, as well as the exact distribution of incoming light, accurate
predictions can be made about how the Rayleigh scattered light will be reflected. It may also be
useful to make predictions about the prevailing conditions in the upcoming solar eclipse. With a
little work this model can be extended to model other types of scattering as well.
This simulator could be made to run in parallel on the Linux cluster in the Romney building
by making use of the message passing interface (mpi). This would allow detailed tests to be run
on the scale of hundreds of millions of photons in a manageable amount of time. It could also be
improved by creating an interface that would allow the user to configure and run a test without
having to code a main method, even if it came at the cost of a little flexibility.
28
Bibliography
[1] Scattering of radiation with polarization. University of Maryland.
[2] Barry A. Bodhaine, Norman B. Wood, Ellsworth G. Dutton, and James R. Slusser. On rayleighoptical depth calculations. Journal of Atmospheric and Oceanic Technology, 16:1854–1861,1999.
[3] H. Van de Hulst. Multiple Light Scattering. Elsevier inc, Woodbury, NY, 1980.
[4] Vladamir Kuzmina and Igor Meglinski. Helicity fip of the backscattered circular polarized light.Proc of SPIE, 7537.
[5] K. N. Liou. An Introduction to Atmospheric Radiation. Academic Press, San Diego, CA, secondedition, 2002.
[6] Nathan J. Pust and Joseph A. Shaw. Dual-eld imaging polarimeter using liquid crystal variableretarders. Applied Optics, 45.
[7] Joseph A. Shaw. Remote sensing systems. Montana State University.
29
Appendix A
Simulator Source Code
Atmosphere.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Atmosphere Header∗ 1−9−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f ATMOSPHERE H#d e f i n e ATMOSPHERE H
#inc lude <g s l / gs l const num . h>#inc lude ” Rayle igh . h”#inc lude ”Photon . h”
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Atmosphere Class∗ A medium through which photons may pass .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s Atmosphere : pub l i c Rayle igh{
p r i v a t e :enum Gas {N2 , O2, AR, CO2} ;// Perc i ent compos i t ion by volumeconst s t a t i c double COMPOSITION [ 4 ] ;// Density by mole/mˆ3const s t a t i c double DENSITY = 22414 ;const s t a t i c double NA = GSL CONST NUM AVOGADRO;
double ge tCros sSec t i on ( const Photon &photon , Gas gas ) const ;double getKingFactor ( const Photon &photon , Gas gas ) const ;double getDens i ty (Gas gas ) const ;
31
double ge tRe f ra c t i v e Index ( const Photon &photon ) const ;pub l i c :
Atmosphere ( ) : Rayle igh ( ) {} ;Atmosphere ( Point po int ) : Rayle igh ( po int ) {} ;Atmosphere ( double ∗ coord inate ) : Rayle igh ( coord inate ) {} ;Atmosphere ( double rad iu s ) : Rayle igh ( rad iu s ) {} ;Atmosphere ( Point point , double rad iu s ) : Rayle igh ( point , r ad iu s ) {} ;Atmosphere ( double ∗ coord inate , double rad iu s ) :
Rayle igh ( coord inate , r ad iu s ) {} ;Atmosphere ( const Medium & medium) : Rayle igh (medium) {} ;v i r t u a l double getFreeDis tance ( const Photon &photon ) const ;v i r t u a l double getFreeTime ( const Photon &photon ) const ;
} ;#e n d i f
32
Atmosphere.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Atmosphere Class∗ 1−9−2015∗ For more in fo rmat ion see :∗ Bodhaine , B. A. , Wood, N. B. , Dutton , E. G. , and S lu s s e r ,∗ J . R . : On Rayle igh o p t i c a l depth c a l c u l a t i o n s , J . Atm.∗ Ocean Technol . , 16 , 1854 1 8 6 1 , 1999 .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <iostream>#inc lude <math . h>#inc lude ”Atmosphere . h”#inc lude ”Photon . h”us ing namespace std ;
const double Atmosphere : : COMPOSITION[ 4 ] = { . 78084 , . 20946 , . 00934 , . 0 0 036} ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Density∗ Get the dens i ty o f the gas (% by volume ∗ mole/mˆ3 ∗ NA) .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Atmosphere : : getDens i ty (Gas gas ) const{
re turn COMPOSITION[ gas ] ∗ DENSITY ∗ NA;}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Cross Sec t i on∗ The c r o s s s e c t i o n i s used in determining how f a r a photon∗ t r a v e l s be f o r e being s c a t t e r e d .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Atmosphere : : g e tCros sSec t i on ( const Photon &photon , Gas gas ) const{
double r i = ge tRe f rac t i v e Index ( photon ) ;double r i 2 = pow( r i , 2 ) ; // r i ˆ2double dens i ty = getDens i ty ( gas ) ; // molecu le s per mˆ3double k f = getKingFactor ( photon , gas ) ;r e turn 24 ∗ pow(M PI , 3) ∗ pow( r i 2 − 1 , 2) / (pow( photon . getWavelength ( ) , 4)∗ pow( dens i ty , 2) ∗ pow( r i 2 + 2 , 2 ) ) ∗ kf ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗33
∗ Get King Factor∗ The king f a c t o r i s r e l a t e d to the d e p o l a r i z a t i o n constant∗ o f a gas , and i s need to c a l c u l a t e the c r o s s s e c t i o n . I t∗ v a r i e s from one gas to another .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Atmosphere : : getKingFactor ( const Photon &photon , Gas gas ) const{
double k ingFactor = 0 ;switch ( gas ){
case N2 :k ingFactor = 1.034 + .000317 / pow( photon . getWavelength ( ) , 2 ) ;break ;
case O2 :k ingFactor = 1.096 + .001385 / pow( photon . getWavelength ( ) , 2) +
.0001448 / pow( photon . getWavelength ( ) , 4 ) ;break ;
case AR:kingFactor = 1 . 0 0 ;break ;k ingFactor = 1 . 1 5 ;
case CO2:break ;
}re turn kingFactor ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get R e f r a c t i v e Index∗ The r e f r a c t i v e index o f a i r f o r a g iven f requency .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Atmosphere : : g e tRe f r a c t i v e Index ( const Photon &photon ) const{
double one over lambda2 = pow( photon . getWavelength ( ) , −2);r e turn (8 .6051 + 2480990 / (132 .274 − one over lambda2 ) + 17455.7 /
(39 .32957 − one over lambda2 ) ) ∗ .00000001 + 1 ;}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Free Distance∗ Return the d i s t anc e a photon w i l l t r a v e l be f o r e an∗ i n t e r a c t i o n ( does not need to be the same each time ) .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Atmosphere : : ge tFreeDis tance ( const Photon &photon ) const
34
{// c a l c u l a t e the d i s t anc e the photon w i l l t r a v e l becuase o f// each p a r t i a l p r e s su r e o f gasdouble d i s t anc e [ 4 ] = {0 , 0 , 0 , 0} ;// based on a c o r r e c t random d i s t r i b u t i o n that i s// c a l c u l a t e d independent ly from the other d i s t a n c e sd i s t anc e [ 0 ] = − ( l og (1 − getRS ( ) . rand ( ) ) ) / ( getDens i ty (N2) ∗
ge tCros sSec t i on ( photon , N2 ) ) ;d i s t anc e [ 1 ] = − ( l og (1 − getRS ( ) . rand ( ) ) ) / ( getDens i ty (O2) ∗
ge tCros sSec t i on ( photon , N2 ) ) ;d i s t anc e [ 2 ] = − ( l og (1 − getRS ( ) . rand ( ) ) ) / ( getDens i ty (AR) ∗
ge tCros sSec t i on ( photon , N2 ) ) ;d i s t anc e [ 3 ] = − ( l og (1 − getRS ( ) . rand ( ) ) ) / ( getDens i ty (CO2) ∗
ge tCros sSec t i on ( photon , N2 ) ) ;i n t n = 0 ;i n t i ;// s e l e c t the s h o r t e s t o f the se d i s t a n c e sf o r ( i = 1 ; i < 4 ; i++){
i f ( d i s t ance [ i ] < d i s t anc e [ n ] ){
n = i ;}
}re turn d i s t anc e [ n ] ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Free Time∗ Return the time a photon w i l l t r a v e l b e f o r e an∗ i n t e r a c t i o n ( does not need to be the same each time ) .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Atmosphere : : getFreeTime ( const Photon &photon ) const{
re turn getFreeDis tance ( photon ) / Photon : : getC ( ) ;}
35
Detector.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Detector Header∗ 1−23−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f DETECTOR H#d e f i n e DETECTOR H
#inc lude ”Photon . h”#inc lude ” Point . h”#inc lude ” Sol idAngle . h”
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Detector Class∗ This c l a s s s imu la t e s l i g h t de t e c t o r .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s Detector{
p r i v a t e :Point l o c a t i o n ;Point la s tContac t ; // Last r e g i s t e r e d po int o f contactSo l idAngle theta ; //0 to p iSo l idAngle phi ; //0 to 2 p idouble rad iu s ;double numDetected ;bool i sNarrowing ( const Point & o r i g i n a l , const Point & next ) const ;double getMinDistance ( const Photon & photon , double & time ) const ;Point getContact ( const Photon & photon , double & minTime ) ;
pub l i c :Detector ( ) : theta ( f a l s e ) , phi ( t rue ) { l o c a t i o n ; l a s tContac t ; r ad iu s = 1 ;
numDetected = 0 ; } ;Detector ( double ∗ coord inate , double thetaMin , double thetaMax ,
double phiMin , double phiMax , double rad iu s ) ;Detector ( const Detector & de t e c t o r ) : l o c a t i o n ( de t e c t o r . getLocat ion ( ) ) ,
l a s tContac t ( de t e c t o r . getLastContact ( ) ) , theta ( de t e c t o r . getTheta ( ) ) ,phi ( d e t e c t o r . getPhi ( ) ){ rad iu s = de t e c t o r . getRadius ( ) ; numDetected = 0 ; } ;
Point getLocat ion ( ) const { re turn l o c a t i o n ; } ; // get the l o c a t i o nSol idAngle getTheta ( ) const { re turn theta ; } ; // get the v e r t i c a l ang leSo l idAngle getPhi ( ) const { re turn phi ; } ; // get the h o r i z o n t a l ang ledouble getRadius ( ) const { re turn rad iu s ; } ;double getNumDetected ( ) const { re turn numDetected ; } ;
36
Point getLastContact ( ) const { re turn la s tContac t ; } ;void s e tLoca t i on ( i n t min , double max) { theta . setMin ( min ) ;
theta . setMax (max ) ; } ;void setTheta ( double min , double max) { theta . setMin ( min ) ;
theta . setMax (max ) ; } ;void setPhi ( double min , double max) {phi . setMin ( min ) ; phi . setMax (max ) ; } ;void setRadius ( double r ) { i f ( r >= 0) rad iu s = r ; } ;void setNumDetected ( double n) { i f (n >= 0) numDetected = n ; } ;v i r t u a l bool detec ted ( const Photon & photon , double amount ,
bool isTime = true ) ;} ;#e n d i f
37
Detector.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Detector Class∗ 1−21−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <iostream>#inc lude <cmath>#inc lude ” Detector . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Detector∗ I n i t i a l i z e everyth ing . Phi must be a f u l l angle , and∗ theta a h a l f ang le .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Detector : : Detector ( double ∗ coord inate , double thetaMin , double thetaMax ,
double phiMin , double phiMax , double rad iu s ) : l a s tContac t ( ) ,theta ( thetaMin , thetaMax , f a l s e ) , phi ( phiMin , phiMax , t rue )
{f o r ( i n t i = 0 ; i < Point : : SIZE ; i++){
l o c a t i o n . se tCoord inate ( i , coo rd inate [ i ] ) ;}th i s−>rad iu s = rad iu s ;numDetected = 0 ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ I s Narrowing∗ Determine whether the next po int i s narrowing the minimum∗ d i s t anc e to the l o c a t i o n o f t h i s detector , even i f i t i s∗ f a r t h e r away than the o r i g i n a l po int . The check i s made∗ by s e e i n g i f the d i s t anc e between the o r i g i n a l and next∗ po in t s squared p lus the d i s t anc e from the de t e c t o r to the∗ o r i g i n a l squared i s l e s s than or equal to the d i s t anc e∗ between the next po int and the de t e c t o r squared∗ ( pythagorean theorem ) . I f the l o c a t i o n o f t h i s d e t e c t o r∗ and both o f the se po in t s were to l i e on a s t r a i g h t l i n e∗ in 3d space , t h i s func t i on would re turn true i f the∗ de t e c t o r were between the other two po in t s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/bool Detector : : i sNarrowing ( const Point & o r i g i n a l , const Point & next ) const
38
{double dOr ig ina l = getLocat ion ( ) . ge tDi s tance ( o r i g i n a l ) ;double dNext = getLocat ion ( ) . ge tDi s tance ( next ) ;double dCheck = o r i g i n a l . ge tDi s tance ( next ) ;r e turn pow( dOrig ina l , 2) + pow( dCheck , 2) >= pow( dNext , 2 ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Min Distance∗ Calcu la te the minimum d i s t anc e from the cente r o f t h i s∗ de t e c t o r that a photon w i l l be at any given po int along∗ the path i s w i l l t r a v e r s e in the g iven time . Update the∗ amout o f time i t took to get the re . I f 0 or the f u l l time∗ are the optimal va lue s in the g iven range , r e turn those∗ va lue s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Detector : : getMinDistance ( const Photon & photon , double & time ) const{
Photon p = photon ; // s i n c e we are not going to change photonp . advance ( time ) ; // move the photon the f u l l time along i t s t r a j e c t o r ydouble d I n i t i a l = photon . getLocat ion ( ) . ge tDi s tance ( l o c a t i o n ) ; // 0 timedouble dFinal = p . getLocat ion ( ) . ge tDi s tance ( l o c a t i o n ) ; // f u l l timei f ( d I n i t i a l < dFinal && ! isNarrowing ( photon . getLocat ion ( ) , p . getLocat ion ( ) ) ){
// the c l o s e s t po int i s behind the photontime = 0 ;re turn d I n i t i a l ;
}e l s e i f ( d I n i t i a l > dFinal && ! isNarrowing (p . getLocat ion ( ) ,
photon . getLocat ion ( ) ) ){
// the c l o s e s t po int i s f a r t h e r ahead than the photon had time to t r a v e l tore turn dFinal ;
}// norma l i za t i on constant f o r the componenets o f the v e l o c i t y o f the photondouble n = p . normal ize ( ) ;double vx = photon . g e tVe l o c i t y ( ) [ 0 ] ∗ n ;double vy = photon . g e tVe l o c i t y ( ) [ 1 ] ∗ n ;double vz = photon . g e tVe l o c i t y ( ) [ 2 ] ∗ n ;double px = photon . getLocat ion ( ) [ 0 ] ;double py = photon . getLocat ion ( ) [ 1 ] ;double pz = photon . getLocat ion ( ) [ 2 ] ;double lx = getLocat ion ( ) [ 0 ] ;double ly = getLocat ion ( ) [ 1 ] ;
39
double l z = getLocat ion ( ) [ 2 ] ;// t h i s equat ion i s der ived by r e a l i z i n g the dot product o f the v e l o c i t y// o f the photon and the vec to r from the photon to the detector ’ s l o c a t i o n// must be zero at the po int we are s e ek ingtime = ( vx ∗ ( l x − px ) + vy ∗ ( l y − py ) + vz ∗ ( l z − pz ) ) / (pow( vx , 2) +
pow( vy , 2) + pow( vz , 2 ) ) ;p = photon ;p . advance ( time ) ;r e turn p . getLocat ion ( ) . ge tDis tance ( getLocat ion ( ) ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Contact∗ Calcu la te the po int o f contact the photon w i l l make .∗ Assume that the minTime i s the time to get to the c l o s e s t∗ po int along the path , and that the photon w i l l be at that∗ po int be with in the rad iu s . Set the c a l c u l a t e d po int as∗ the l a s t contact r e g i s t e r e d to t h i s d e t e c t o r .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Point Detector : : getContact ( const Photon & photon , double & minTime){
Photon p = photon ;i n t n = 1 ;double t = minTime / pow(2 , n++);double tPrev = 0 ;double d = 0 ;double dPrev = photon . getLocat ion ( ) . ge tDis tance ( l o c a t i o n ) ;// binary searchwhi l e (d < rad iu s && t != tPrev ){
p = photon ;p . advance ( t ) ;d = p . getLocat ion ( ) . ge tDi s tance ( l o c a t i o n ) ;t = tPrev ;i f (d < rad iu s ) // we are i n s i d e the radius , t should be sma l l e r{
t −= minTime / pow(2 , n++);dPrev = d ;
}e l s e i f (d > rad iu s ) // we are ou t s i d e the radius , t should be b igge r{
t += minTime / pow(2 , n++);d = dPrev ;
}
40
}l a s tContac t = p . getLocat ion ( ) ; // keep track o f t h i s po intre turn la s tContac t ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Detected∗ Determine whether the g iven photon w i l l be absorbed by∗ the de t e c t o r . Note : i f t h i s method re tu rn s t rue then the∗ po int o f l a s t contact w i l l have been r e s e t .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/bool Detector : : de tec ted ( const Photon & photon , double amount , bool isTime ){
i f ( photon . getLocat ion ( ) . ge tDi s tance ( l o c a t i o n ) < rad iu s ){
// a l r eady past the de t e c t o rre turn f a l s e ;
}double time ;i f ( isTime ) // they gave us time to t r a v e l{
time = amount ;}e l s e // they gave us d i s t anc e to t r a v e l{
time = amount / Photon : : getC ( ) ;}double minTime = time ;double minDistance = getMinDistance ( photon , minTime ) ;i f ( minDistance > rad iu s ) // we never get c l o s e enough{
re turn f a l s e ;}Point contact = getContact ( photon , minTime ) ; // get where we h i tdouble r = s q r t (pow( contact . getCoordinate ( 0 ) , 2) +
pow( contact . getCoordinate ( 1 ) , 2 ) ) ; // s q r t ( xˆ2 + y ˆ2)// ang l e s o f po int o f contact from the d e t e c t o r s l o c a t i o ndouble anglePhi = atan2 ( contact . getCoordinate (1 ) − l o c a t i o n . getCoordinate ( 1 ) ,
contact . getCoordinate (0 ) − l o c a t i o n . getCoordinate ( 0 ) ) ∗ 180 / M PI ;double angleTheta = atan2 ( r , contact . getCoordinate (2 ) −
l o c a t i o n . getCoordinate ( 2 ) ) ∗ 180 / M PI ;// t rue i f the po int was in v a l i d rangereturn phi . i sInRange ( anglePhi ) && theta . isInRange ( angleTheta ) ;
}
41
Histogram.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Histogram Header∗ 3−25−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f HISTOGRAM H#d e f i n e HISTOGRAM H
#inc lude <iostream>#inc lude <s t r i ng>
us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Histogram Class∗ This c l a s s keeps t rack o f the number o f e n t r i e s in∗ equa l l y s i z e d conse cu t i v e b ins .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s Histogram{
protec ted :i n t ∗ bins ;unsigned i n t numBins ;double b inS i z e ;double i n i t i a l ;
pub l i c :Histogram ( unsigned i n t numBins , double b inS ize , double i n i t i a l ) ;Histogram ( const Histogram & h ) ;˜Histogram ( ) { d e l e t e [ ] b ins ; } ;i n t ∗ getBins ( ) const { re turn b ins ; } ;unsigned i n t getNumBins ( ) const { re turn numBins ; } ;double ge tB inS i ze ( ) const { re turn b inS i z e ; } ;double g e t I n i t i a l ( ) const { re turn i n i t i a l ; } ;s t r i n g toS t r i ng ( ) const ;double operator [ ] ( i n t i ) const { i f ( i >= 0 && i < numBins ) re turn b ins [ i ] ;
e l s e re turn 0 ; } ;double operator [ ] ( double n) const { i n t i = ( i n t ) ( ( n − i n i t i a l ) / b inS i z e ) ;
i f ( i >= 0 && i < numBins ) re turn b ins [ i ] ; e l s e re turn 0 ; } ;void operator<<(double n) { i n t i = ( i n t ) ( ( n − i n i t i a l ) / b inS i z e ) ;
i f ( i >= 0 && i < numBins ) b ins [ i ]++;} ;} ;#e n d i f
42
Histogram.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Histogram Source∗ 3−25−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <sstream>#inc lude ”Histogram . h”
us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Constructor∗ I n i t i a l i z e the va lue s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Histogram : : Histogram ( unsigned i n t numBins , double b inS ize , double i n i t i a l ){
th i s−>numBins = numBins ;th i s−>b inS i z e = b inS i z e ;th i s−> i n i t i a l = i n i t i a l ;b ins = new i n t [ numBins ] ;f o r ( i n t i = 0 ; i < numBins ; i++){
bins [ i ] = 0 ;}
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Copy Constructor∗ Make an independent copy o f h .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Histogram : : Histogram ( const Histogram & h){
th i s−>numBins = h . numBins ;th i s−>b inS i z e = h . b inS i z e ;th i s−> i n i t i a l = h . i n i t i a l ;b ins = new i n t [ h . numBins ] ;f o r ( i n t i = 0 ; i < h . numBins ; i++){
th i s−>bins [ i ] = h . b ins [ i ] ;}
}
43
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ To St r ing∗ Return ”bin− i n i t i a l bin−f i n a l bin−count\n” f o r a l l b ins .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/s t r i n g Histogram : : t oS t r i ng ( ) const{
s t r i ng s t r eam stream ;f o r ( i n t i = 0 ; i < numBins ; i++){
stream << ( i n i t i a l + i ∗ b inS i z e ) << ” ” << ( i n i t i a l + ( i + 1) ∗ b inS i z e )<< ” ” << bins [ i ] << ”\n ” ;
}re turn stream . s t r ( ) ;
}
44
makefile
############################################################ S c a t t e r i n g# James Nelson# 1−8−15###########################################################a l l : PiApproximation . out TestDetector . out TestSource . out
Tes tV i s ib l eSource . out TestPhoton . out TestMedium . outTestRayle igh . out TestPoint . out TestSo l idAngle . outTestRotat ion . out TestRandomSingleton . out TestAtmosphere . outTestS imulat ion . out TestHistogram . out SimulateAtmosphere . out
echo ”Done”
PiApproximation : PiApproximation . out. / PiApproximation . out
TestDetector : TestDetector . out. / TestDetector . out
TestSource : TestSource . out. / TestSource . out
Tes tV i s ib l eSource : Tes tV i s ib l eSource . out. / Tes tV i s ib l eSource . out
TestPhoton : TestPhoton . out. / TestPhoton . out
TestMedium : TestMedium . out. / TestMedium . out
TestRayle igh : TestRayle igh . out. / TestRayle igh . out
TestPoint : TestPoint . out. / TestPoint . out
TestSo l idAngle : TestSo l idAngle . out. / TestSo l idAngle . out
TestRotat ion : TestRotat ion . out. / TestRotat ion . out
TestRandomSingleton : TestRandomSingleton . out. / TestRandomSingleton . out
TestAtmosphere : TestAtmosphere . out. / TestAtmosphere . out
TestS imulat ion : TestS imulat ion . out. / TestS imulat ion . out
TestHistogram : TestHistogram . out. / TestHistogram . out
SimulateAtmosphere : SimulateAtmosphere . out. / SimulateAtmosphere . out
45
PiApproximation . out : PiApproximation . o Source . o Detector . oSo l idAngle . o Photon . o Point . o RandomSingleton . o
g++ −o PiApproximation . out PiApproximation . o Source . oDetector . o So l idAngle . o Photon . o Point . oRandomSingleton . o − l g s l − l g s l c b l a s
TestDetector . out : TestDetector . o Detector . o So l idAngle . oPhoton . o Point . o
g++ −o TestDetector . out TestDetector . o Detector . oSo l idAngle . o Photon . o Point . o RandomSingleton . o− l g s l − l g s l c b l a s
TestSource . out : TestSource . o Source . o So l idAngle . o Photon . oPoint . o RandomSingleton . o
g++ −o TestSource . out TestSource . o Source . o So l idAngle . oPhoton . o Point . o RandomSingleton . o − l g s l − l g s l c b l a s
Tes tV i s ib l eSource . out : Tes tV i s ib l eSource . o V i s i b l eSou r c e . oSource . o So l idAngle . o Photon . o Point . o RandomSingleton . o
g++ −o Tes tV i s ib l eSource . out Tes tV i s ib l eSource . oV i s i b l eSou r c e . o Source . o So l idAngle . o Photon . o Point . oRandomSingleton . o − l g s l − l g s l c b l a s
TestPhoton . out : TestPhoton . o Photon . o Point . og++ −o TestPhoton . out TestPhoton . o Photon . o Point . o
TestMedium . out : TestMedium . o Photon . o Medium . o Point . oRotation . o RandomSingleton . o
g++ −o TestMedium . out TestMedium . o Photon . o Point . oMedium . o Rotation . o RandomSingleton . o − l g s l − l g s l c b l a s
TestRayle igh . out : TestRayle igh . o Photon . o Rayle igh . o Point . oMedium . o Rotation . o RandomSingleton . o
g++ −o TestRayle igh . out TestRayle igh . o Photon . o Point . oRayle igh . o Medium . o Rotation . o RandomSingleton . o− l g s l − l g s l c b l a s
TestAtmosphere . out : TestAtmosphere . o Photon . o Rayle igh . o Point . oMedium . o Rotation . o RandomSingleton . o Atmosphere . o
g++ −o TestAtmosphere . out TestAtmosphere . o Photon . o Point . oRayle igh . o Medium . o Rotation . o RandomSingleton . oAtmosphere . o − l g s l − l g s l c b l a s
TestPoint . out : TestPoint . o Point . og++ −o TestPoint . out TestPoint . o Point . o
TestSo l idAngle . out : TestSo l idAngle . o So l idAngle . og++ −o TestSo l idAngle . out TestSo l idAngle . o So l idAngle . o
TestRotat ion . out : TestRotat ion . o Rotation . og++ −o TestRotat ion . out TestRotat ion . o Rotation . o
TestRandomSingleton . out : TestRandomSingleton . o RandomSingleton . og++ −o TestRandomSingleton . out TestRandomSingleton . o
RandomSingleton . o − l g s l − l g s l c b l a s
46
TestSimulat ion . out : TestS imulat ion . o Simulat ion . o Medium . oRayle igh . o Atmosphere . o Source . o V i s i b l eSou r c e . o Detector . oPhoton . o Point . o So l idAngle . o Rotation . o RandomSingleton . o
g++ −o TestSimulat ion . out TestS imulat ion . o Simulat ion . oMedium . o Rayle igh . o Atmosphere . o Source . o V i s i b l eSou r c e . oDetector . o Photon . o Point . o So l idAngle . o Rotation . oRandomSingleton . o − l g s l − l g s l c b l a s
TestHistogram . out : TestHistogram . o Histogram . og++ −o TestHistogram . out TestHistogram . o Histogram . o
SimulateAtmosphere . out : SimulateAtmosphere . o Va l idat i onS imulat i on . oSimulat ion . o Medium . o Rayle igh . o Atmosphere . o Source . oV i s i b l eSou r c e . o Detector . o Photon . o Point . o So l idAngle . oRotation . o RandomSingleton . o Histogram . o
g++ −o SimulateAtmosphere . out SimulateAtmosphere . oVa l idat ionS imula t i on . o Simulat ion . o Medium . o Rayle igh . oAtmosphere . o Source . o V i s i b l eSou r c e . o Detector . o Photon . oPoint . o So l idAngle . o Rotation . o RandomSingleton . oHistogram . o − l g s l − l g s l c b l a s
PiApproximation . o : PiApproximation . cppg++ −c PiApproximation . cpp
Detector . o : Detector . h Detector . cpp Sol idAngle . h So l idAngle . cppPoint . h Point . cpp Photon . h Photon . cpp
g++ −c Detector . cppTestDetector . o : Detector . h TestDetector . cpp Photon . h Photon . cpp
g++ −c TestDetector . cppSource . o : Source . h Source . cpp Sol idAngle . h So l idAngle . cpp Point . h
Point . cpp Photon . h Photon . cpp RandomSingleton . hRandomSingleton . cpp
g++ −c Source . cppTestSource . o : Source . h TestSource . cpp Photon . h Photon . cpp
g++ −c TestSource . cppV i s i b l eSou r c e . o : V i s i b l eSou r c e . h V i s i b l eSou r c e . cpp Source . h
Source . cpp Sol idAngle . h So l idAngle . cpp Point . h Point . cppPhoton . h Photon . cpp RandomSingleton . h RandomSingleton . cpp
g++ −c V i s i b l eSou r c e . cppTes tV i s ib l eSource . o : V i s i b l eSou r c e . h Tes tV i s ib l eSource . cpp
Source . h Source . cpp Photon . h Photon . cppg++ −c Tes tV i s ib l eSource . cpp
Photon . o : Photon . h Photon . cppg++ −c Photon . cpp
TestPhoton . o : Photon . h TestPhoton . cpp Point . h Point . cppg++ −c TestPhoton . cpp
Medium . o : Medium . h Medium . cpp Photon . h Point . h Rotation . hRotation . cpp
47
g++ −c Medium . cppTestMedium . o : Medium . h TestMedium . cpp Photon . h Point . h
Rotation . h Rotation . cppg++ −c TestMedium . cpp
Rayle igh . o : Rayle igh . h Rayle igh . cpp Medium . h Medium . cppPhoton . h Point . h
g++ −c Rayle igh . cppTestRayle igh . o : Rayle igh . h TestRayle igh . cpp Medium . h Medium . cpp
Photon . h Point . hg++ −c TestRayle igh . cpp
Point . o : Point . h Point . cppg++ −c Point . cpp
TestPoint . o : Point . h TestPoint . cppg++ −c TestPoint . cpp
Sol idAngle . o : So l idAngle . h So l idAngle . cppg++ −c So l idAngle . cpp
TestSo l idAngle . o : So l idAngle . h TestSo l idAngle . cppg++ −c TestSo l idAngle . cpp
Rotation . o : Rotation . h Rotation . cppg++ −c Rotation . cpp
TestRotat ion . o : Rotation . h TestRotat ion . cppg++ −c TestRotat ion . cpp
RandomSingleton . o : RandomSingleton . h RandomSingleton . cppg++ −c RandomSingleton . cpp
TestRandomSingleton . o : RandomSingleton . hTestRandomSingleton . cpp
g++ −c TestRandomSingleton . cppAtmosphere . o : Atmosphere . h Atmosphere . cpp
g++ −c Atmosphere . cppTestAtmosphere . o : Atmosphere . h TestAtmosphere . cpp
g++ −c TestAtmosphere . cppSimulat ion . o : S imulat ion . h Simulat ion . cpp
g++ −c Simulat ion . cppTestSimulat ion . o : S imulat ion . h TestSimulat ion . cpp
g++ −c TestS imulat ion . cppHistogram . o : Histogram . h Histogram . cpp
g++ −c Histogram . cppTestHistogram . o : Histogram . h TestHistogram . cpp
g++ −c TestHistogram . cppVa l idat ionS imula t i on . o : Va l idat ionS imulat i on . h
Va l idat ionS imula t i on . cpp Simulat ion . h Simulat ion . cppHistogram . h Histogram . cpp
g++ −c Va l idat i onS imulat i on . cppSimulateAtmosphere . o : Va l idat i onS imulat i on . h Simulat ion . h
48
Histogram . h SimulateAtmosphere . cppg++ −c SimulateAtmosphere . cpp
copy :cp ∗ . cpp ∗ . h make f i l e . . / Backup / .
c l ean :rm ∗ . o ∗ . out
49
Medium.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Medium Header∗ 1−8−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f MEDIUM H#d e f i n e MEDIUM H
#inc lude ”Photon . h”#inc lude ” Point . h”#inc lude ” Rotation . h”#inc lude ”RandomSingleton . h”
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Medium Class∗ This c l a s s s imu la t e s a medium f o r photons to pass∗ through . Chi ldren c l a s s e s can absorb and s c a t t e r them as∗ d e s i r e d .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s Medium{
protec ted :Point l o c a t i o n ;Rotation r o t a t e r ;double rad iu s ;
pub l i c :Medium ( ) : r o t a t e r (1 , 0 , 0) { rad iu s = 1 . 0 ; } ;Medium( Point po int ) : l o c a t i o n ( po int ) , r o t a t e r (1 , 0 , 0) { rad iu s = 1 . 0 ; } ;Medium( double ∗ coord inate ) : l o c a t i o n ( coord inate ) , r o t a t e r (1 , 0 , 0)
{ rad iu s = 1 . 0 ; } ;Medium( double rad iu s ) : r o t a t e r (1 , 0 , 0) { th i s−>rad iu s = rad iu s ; } ;Medium( Point point , double rad iu s ) : l o c a t i o n ( po int ) , r o t a t e r (1 , 0 , 0)
{ th i s−>rad iu s = rad iu s ; } ;Medium( double ∗ coord inate , double rad iu s ) : l o c a t i o n ( coord inate ) ,
r o t a t e r (1 , 0 , 0) { th i s−>rad iu s = rad iu s ; } ;Medium( const Medium & medium) : l o c a t i o n (medium . getLocat ion ( ) ) ,
r o t a t e r (1 , 0 , 0) { th i s−>rad iu s = medium . getRadius ( ) ; } ;Point getLocat ion ( ) const { re turn l o c a t i o n ; } ; // get the cur rent l o c a t i o ndouble getRadius ( ) const { re turn rad iu s ; } ;Rotation getRotater ( ) const { re turn r o t a t e r ; } ;v i r t u a l double getFreeDis tance ( const Photon &photon ) const ;v i r t u a l double getFreeTime ( const Photon &photon ) const ;
50
s t a t i c RandomSingleton & getRS ( ) { re turn RandomSingleton : : g e t In s tance ( ) ; } ;void s e tLoca t i on ( i n t i , double n ) ;void se tRotate r ( double x , double y , double z ) { r o t a t e r . s e tAx i s (0 , x ) ;
r o t a t e r . s e tAx i s (1 , y ) ; r o t a t e r . s e tAx i s (2 , z ) ; } ;void setRadius ( double r ) { i f ( r >= 0) rad iu s = r ; } ;bool isInMedium ( const Point &point ) const
{ re turn po int . ge tDi s tance ( l o c a t i o n ) <= rad iu s ; } ;v i r t u a l void s c a t t e r ( Photon &photon ) ;
} ;#e n d i f
51
Medium.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Medium Class∗ 1−8−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <c s t d l i b>#inc lude ”Medium . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Set Locat ion∗ Set a s p e c i f i c coo rd ina te o f the l o c a t i o n .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Medium : : s e tLoca t i on ( i n t i , double n){
i f ( i >= 0 && i < Point : : SIZE )l o c a t i o n . se tCoord inate ( i , n ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Free Distance∗ Return the d i s t anc e a photon w i l l t r a v e l be f o r e an∗ i n t e r a c t i o n ( does not need to be the same each time ) .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Medium : : getFreeDis tance ( const Photon &photon ) const{
re turn rand ( ) ; // r e w r i t e t h i s f o r c h i l d r e n c l a s s e s}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Free Time∗ Return the time a photon w i l l t r a v e l b e f o r e an∗ i n t e r a c t i o n ( does not need to be the same each time ) .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Medium : : getFreeTime ( const Photon &photon ) const{
re turn rand ( ) ; // r e w r i t e t h i s f o r c h i l d r e n c l a s s e s}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Sca t t e r∗ This i s the ba s i c func t i on to change the v e l o c i t y , and
52
∗ p o s s i b l y the f requency and p l a r i z a t i o n o f a g iven∗ photon . Should c a l l increment on the photon .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Medium : : s c a t t e r ( Photon &photon ){
i f ( isInMedium ( photon . getLocat ion ( ) ) ){
f o r ( i n t i = 0 ; i < Point : : SIZE ; i++){
photon . s e t V e l o c i t y ( i , rand ( ) % 3 − 1 ) ;}photon . increment ( ) ;
}}
53
Photon.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Photon Header∗ 1−8−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f PHOTON H#d e f i n e PHOTON H
#inc lude <s t r i ng>#inc lude ” Point . h”#inc lude <g s l / g s l cons t mksa . h>us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Photon Class∗ This c l a s s s imu la t e s a photon and keeps t rack o f∗ r e l e v a n t data . Al l d i s t a n c e s are in meters , a l l t imes are∗ in seconds , a l l ang l e s are in degrees , and a l l e n e r g i e s∗ are in Jou l e s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s Photon{
p r i v a t e :Point l o c a t i o n ; // where the photon i sPoint o r i g i n ; // where the photon s t a r t e dPoint v e l o c i t y ; // which way the photon i s goingdouble f requency ; // keeps t rack o f wavelength and energy a l s o
// ang le o f E f i e l d o s c i l l a t i o n to a r b i t r a r y axis ,// as viewed from the source
double o r i e n t a t i o n ;double phase ; // phase between E and B maximai n t c i r c u l a r P o l a r i z a t i o n ; //1 f o r ccw from source , −1 f o r cw , 0 f o r n e i t h e runsigned i n t numInteract ions ; // number o f i n t e r a c t i o n s
void i n i t i a l i z e ( ) ;pub l i c :
Photon ( ) ; // d e f a u l t s are 0 or randomPhoton ( double f requency ) ; // s e t the f requencyPhoton ( double ∗ o r i g i n , double ∗ v e l o c i t y ) ; // s e t the o r i g i n
// s e t the o r i g i n and the f requencyPhoton ( double ∗ o r i g i n , double ∗ v e l o c i t y , double f requency ) ;
// s e t everyth ing
54
Photon ( double ∗ o r i g i n , double ∗ v e l o c i t y , double frequency ,double o r i e n t a t i o n , double phase , i n t c i r c u l a r P o l a r i z a t i o n ) ;
Photon ( Point o r i g i n , Point v e l o c i t y , double frequency , double o r i e n t a t i o ndouble phase , i n t c i r c u l a r P o l a r i z a t i o n ) ; // s e t everyth ing
Photon ( const Photon & photon ) {∗ t h i s = photon ; } ; // copy photon˜Photon ( ) {} ;Point getLocat ion ( ) const { re turn l o c a t i o n ; } ; // get the cur rent l o c a t i o nPoint ge tOr ig in ( ) const { re turn o r i g i n ; } ; // get the o r i g i n a l l o c a t i o nPoint g e tVe l o c i t y ( ) const { re turn v e l o c i t y ; } ; // get the v e l o c i t ys t a t i c double getC ( ) { re turn GSL CONST MKSA SPEED OF LIGHT ; } ;s t a t i c double getH ( ) { re turn GSL CONST MKSA PLANCKS CONSTANT H; } ;double getFrequency ( ) const { re turn f requency ; } ;double getWavelength ( ) const { re turn getC ( ) / f requency ; } ; // l=c/ fdouble getEnergy ( ) const { re turn getH ( ) ∗ f r equency ; } ; // E=hfdouble ge tOr i en ta t i on ( ) const ;double getPhase ( ) const { re turn phase ; } ;i n t g e t C i r c u l a r P o l a r i z a t i o n ( ) const { re turn c i r c u l a r P o l a r i z a t i o n ; } ;bool isCCW( ) const { re turn c i r c u l a r P o l a r i z a t i o n == 1;}bool isCW( ) const { re turn c i r c u l a r P o l a r i z a t i o n == −1;}bool i s L i n e a r ( ) const { re turn c i r c u l a r P o l a r i z a t i o n == 0;}
// d i s t anc e between coord inate s , not t o t a l d i s t anc e t r a v e l e ddouble getDistanceFromOrigin ( ) const ;unsigned i n t getNumInteract ions ( ) const { re turn numInteract ions ; } ;void s e tLoca t i on ( i n t i , double n ) ;void s e t O r i g i n ( i n t i , double n ) ;void s e t V e l o c i t y ( i n t i , double n ) ;void setFrequency ( double f requency )
{ i f ( f requency >= 0) th i s−>f r equency = frequency ; } ;void setWavelength ( double wavelength )
{ i f ( wavelength > 0) f requency = getC ( ) / wavelength ; } ;void setEnergy ( double energy )
{ i f ( energy > 0) f requency = energy / getH ( ) ; } ;void s e t O r i e n t a t i o n ( double o r i e n t a t i o n ) ;void setPhase ( double phase ) ;i n t s e t C i r c u l a r P o l a r i z a t i o n ( i n t n)
{ i f (n >= −1 && n <= 1) c i r c u l a r P o l a r i z a t i o n = n ; } ;bool setCCW( ) { c i r c u l a r P o l a r i z a t i o n = 1 ;}bool setCW ( ) { c i r c u l a r P o l a r i z a t i o n = −1;}bool s e tL inea r ( ) { c i r c u l a r P o l a r i z a t i o n = 0 ;}void setNumInteract ions ( unsigned i n t n) {numInteract ions = n ; } ;double normal ize ( ) ;void increment ( ) {numInteract ions ++;};void advance ( double amount , bool isTime = true ) ;s t r i n g toS t r i ng ( ) const ;
55
Photon.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Photon Class∗ 1−6−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <iostream>#inc lude <cmath>#inc lude <c s t d l i b>#inc lude <sstream>#inc lude ” Point . h”#inc lude ”Photon . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Photon∗ Set everyth ing to 0 , v e l o c i t y along the x1 axis , and the∗ f r equency to 1 .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Photon : : Photon ( ){
i n i t i a l i z e ( ) ;}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Photon∗ Set the f requency .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Photon : : Photon ( double f requency ){
i n i t i a l i z e ( ) ;setFrequency ( f requency ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Photon∗ Set the coo rd ina t e s and o r i g i n to the g iven po int . Also∗ s e t the v e l o c i t y .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Photon : : Photon ( double ∗ o r i g i n , double ∗ v e l o c i t y ){
i n i t i a l i z e ( ) ;f o r ( i n t i = 0 ; i < Point : : SIZE ; i++)
57
{s e tLoca t i on ( i , o r i g i n [ i ] ) ;s e t O r i g i n ( i , o r i g i n [ i ] ) ;s e t V e l o c i t y ( i , v e l o c i t y [ i ] ) ;
}}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Photon∗ Set the coo rd ina t e s and o r i g i n to the g iven po int . Set∗ the v e l o c i t y and the f requency .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Photon : : Photon ( double ∗ o r i g i n , double ∗ v e l o c i t y , double f requency ){
i n i t i a l i z e ( ) ;f o r ( i n t i = 0 ; i < Point : : SIZE ; i++){
s e tLoca t i on ( i , o r i g i n [ i ] ) ;s e t O r i g i n ( i , o r i g i n [ i ] ) ;s e t V e l o c i t y ( i , v e l o c i t y [ i ] ) ;
}setFrequency ( f requency ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Photon∗ Set the coo rd ina t e s and o r i g i n to the g iven po int . Set∗ the v e l o c i t y , frequency , o r i e n t a t i o n , phase , and c i r c u l a r∗ p o l a r i z a t i o n .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Photon : : Photon ( double ∗ o r i g i n , double ∗ v e l o c i t y , double frequency ,
double o r i e n t a t i o n , double phase , i n t c i r c u l a r P o l a r i z a t i o n ){
i n i t i a l i z e ( ) ;f o r ( i n t i = 0 ; i < Point : : SIZE ; i++){
s e tLoca t i on ( i , o r i g i n [ i ] ) ;s e t O r i g i n ( i , o r i g i n [ i ] ) ;s e t V e l o c i t y ( i , v e l o c i t y [ i ] ) ;
}setFrequency ( f requency ) ;s e t O r i e n t a t i o n ( o r i e n t a t i o n ) ;setPhase ( phase ) ;s e t C i r c u l a r P o l a r i z a t i o n ( c i r c u l a r P o l a r i z a t i o n ) ;
58
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Photon∗ Set the coo rd ina t e s and o r i g i n to the g iven po int . Set∗ the v e l o c i t y , frequency , o r i e n t a t i o n , phase , and c i r c u l a r∗ p o l a r i z a t i o n .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Photon : : Photon ( Point o r i g i n , Point v e l o c i t y , double frequency ,
double o r i e n t a t i o n , double phase , i n t c i r c u l a r P o l a r i z a t i o n ){
i n i t i a l i z e ( ) ;f o r ( i n t i = 0 ; i < Point : : SIZE ; i++){
s e tLoca t i on ( i , o r i g i n . getCoordinate ( i ) ) ;s e t O r i g i n ( i , o r i g i n . getCoordinate ( i ) ) ;s e t V e l o c i t y ( i , v e l o c i t y . getCoordinate ( i ) ) ;
}setFrequency ( f requency ) ;s e t O r i e n t a t i o n ( o r i e n t a t i o n ) ;setPhase ( phase ) ;s e t C i r c u l a r P o l a r i z a t i o n ( c i r c u l a r P o l a r i z a t i o n ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Or i entat ion∗ Get the cur rent o r i e n t a t i o n . For c i r c u l a r p o l a r i z a t i o n∗ the o r i e n a t i o n v a r i a b l e need not change , but the phase∗ must a l s o be cons ide r ed .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Photon : : g e tOr i en ta t i on ( ) const{
double cu r r en tOr i en ta t i on = o r i e n t a t i o n + c i r c u l a r P o l a r i z a t i o n ∗ phase ;i f ( cu r r en tOr i en ta t i on >= 360){
cu r r en tOr i en ta t i on −= 360 ;}e l s e i f ( cu r r en tOr i en ta t i on < 0){
cu r r en tOr i en ta t i on += 360 ;}re turn cur r en tOr i en ta t i on ;
} ;
59
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Distance From Orig in∗ Calcu la te the d i s t ance between the cur rent l o c a t i o n and∗ the o r i g i n .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Photon : : getDistanceFromOrigin ( ) const{
re turn l o c a t i o n . ge tDi s tance ( o r i g i n ) ;}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Set Locat ion∗ Set a s p e c i f i c coo rd ina te o f the l o c a t i o n .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Photon : : s e tLoca t i on ( i n t i , double n){
i f ( i >= 0 && i < Point : : SIZE )l o c a t i o n . se tCoord inate ( i , n ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Set Or ig in∗ Set a s p e c i f i c coo rd ina te o f the o r i g i n .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Photon : : s e t O r i g i n ( i n t i , double n){
i f ( i >= 0 && i < Point : : SIZE )o r i g i n . s e tCoord inate ( i , n ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Set Ve loc i ty∗ Set a s p e c i f i c coo rd ina te o f the v e l o c i t y .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Photon : : s e t V e l o c i t y ( i n t i , double n){
i f ( i >= 0 && i < Point : : SIZE )v e l o c i t y . s e tCoord inate ( i , n ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Set Or i entat i on∗ Set the o r i e n t a t i o n o f the E f i e l d o s c i l l a t i o n to some∗ ang le between 0 and 360 degree s .
60
∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Photon : : s e t O r i e n t a t i o n ( double o r i e n t a t i o n ){
whi le ( o r i e n t a t i o n < 0){
o r i e n t a t i o n += 360 ;}whi le ( o r i e n t a t i o n >= 360){
o r i e n t a t i o n −= 360 ;}th i s−>o r i e n t a t i o n = o r i e n t a t i o n ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Set Phase∗ Set the phase between the E and B f i e l d o s c i l l a t i o n a to∗ some ang le between 0 and 360 degree s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Photon : : setPhase ( double phase ){
whi le ( phase < 0){
phase += 360 ;}whi le ( phase >= 360){
phase −= 360 ;}th i s−>phase = phase ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ I n i t i a l i z e∗ Set d e f a u l t va lue s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Photon : : i n i t i a l i z e ( ){
f o r ( i n t i = 0 ; i < Point : : SIZE ; i++){
s e tLoca t i on ( i , 0 ) ;s e t O r i g i n ( i , 0 ) ;s e t V e l o c i t y ( i , 0 ) ;
}
61
s e t V e l o c i t y (0 , 1 ) ;setFrequency ( 1 . 0 ) ;s e t O r i e n t a t i o n ( 0 ) ;setPhase ( 0 ) ;s e t C i r c u l a r P o l a r i z a t i o n ( 0 ) ;setNumInteract ions ( 0 ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Normalize∗ Return the n o r m a i l i z a t i o n constant f o r the r e l a t i v e∗ va lue s o f the components o f the v e l o c i t y such that the∗ magnitude would be the speed o f l i g h t .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Photon : : normal ize ( ){
i n t square = 0 ; // the sum of each component squaredf o r ( i n t i = 0 ; i < Point : : SIZE ; i++){
square += pow( v e l o c i t y [ i ] , 2 ) ;}i f ( square == 0) // t h i s i s a problem , no d i r e c t i o n i s s p e c i f i e d{
s e t V e l o c i t y (0 , 1 . 0 ) ;square += 1 . 0 ;
}re turn getC ( ) / s q r t ( square ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Advance∗ Change the cur rent coo rd ina t e s o f the photon by advancing∗ along the d i r e c t i o n o f the v e l o c i t y by the amount , which∗ i s time in seconds by d e f a u l t ( but may a l s o be the∗ d i s t anc e in meters ) assuming the the photon t r a v e l s∗ with v e l o c i t y c . Adjust the phase .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Photon : : advance ( double amount , bool isTime ){
double time ;i f ( isTime ) // they gave us time to t r a v e l{
time = amount ;}
62
e l s e // they gave us d i s t anc e to t r a v e l{
time = amount / Photon : : getC ( ) ;}double normal = normal ize ( ) ; // get the constant o f norma l i za t i onf o r ( i n t i = 0 ; i < Point : : SIZE ; i++){
s e tLoca t i on ( i , ge tLocat ion ( ) [ i ] + ge tVe l o c i t y ( ) [ i ] ∗ normal ∗ time ) ;}double pe r i od s = frequency ∗ time ; // the number o f pe r i od s that went by// only the decimal part w i l l a f f e c t the phasedouble phaseChange = 360 ∗ ( pe r i od s − ( long ) pe r i od s ) ;phase += phaseChange ;i f ( phase > 360){
phase −= 360 ;}
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ To St r ing∗ Convert to a s t r i n g .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/s t r i n g Photon : : t oS t r i ng ( ) const{
s t r i ng s t r eam stream ;stream << ”(” << ( getLocat ion ( ) . getCoordinate ( 0 ) ) ;f o r ( i n t i = 1 ; i < Point : : SIZE ; i++){
stream << ” ,” << getLocat ion ( ) . getCoordinate ( i ) ;}stream << ”) , [ ” << getOr ig in ( ) . getCoordinate ( 0 ) ;f o r ( i n t i = 1 ; i < Point : : SIZE ; i++){
stream << ” ,” << getOr ig in ( ) . getCoordinate ( i ) ;}stream << ” ] , <” << ge tVe l o c i t y ( ) . getCoordinate ( 0 ) ;f o r ( i n t i = 1 ; i < Point : : SIZE ; i++){
stream << ” ,” << ge tVe l o c i t y ( ) . getCoordinate ( i ) ;}stream << ”>, ” << f r equency << ” Hz , ” << o r i e n t a t i o n << ” , ”<< phase << ” , #” << numInteract ions ;
r e turn stream . s t r ( ) ;
63
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Print∗ Output a l l o f the va lue s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Photon : : p r i n t ( ) const{
cout << ”(” << getLocat ion ( ) . getCoordinate ( 0 ) ;f o r ( i n t i = 1 ; i < Point : : SIZE ; i++){
cout << ” ,” << getLocat ion ( ) . getCoordinate ( i ) ;}cout << ”) , [ ” << getOr ig in ( ) . getCoordinate ( 0 ) ;f o r ( i n t i = 1 ; i < Point : : SIZE ; i++){
cout << ” ,” << getOr ig in ( ) . getCoordinate ( i ) ;}cout << ” ] , <” << ge tVe l o c i t y ( ) . getCoordinate ( 0 ) ;f o r ( i n t i = 1 ; i < Point : : SIZE ; i++){
cout << ” ,” << ge tVe l o c i t y ( ) . getCoordinate ( i ) ;}cout << ”>, ” << f r equency << ” Hz , ” << o r i e n t a t i o n << ” , ”<< phase << ” , #” << numInteract ions << endl ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Equals∗ Copy the g iven photon .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Photon : : operator=(const Photon & photon ){
f o r ( i n t i = 0 ; i < Point : : SIZE ; i++){
s e tLoca t i on ( i , photon . getLocat ion ( ) [ i ] ) ;s e t O r i g i n ( i , photon . ge tOr ig in ( ) [ i ] ) ;s e t V e l o c i t y ( i , photon . g e tVe l o c i t y ( ) [ i ] ) ;
}setFrequency ( photon . getFrequency ( ) ) ;s e t O r i e n t a t i o n ( photon . ge tOr i en ta t i on ( ) ) ;setPhase ( photon . getPhase ( ) ) ;setNumInteract ions ( photon . getNumInteract ions ( ) ) ;s e t C i r c u l a r P o l a r i z a t i o n ( photon . g e t C i r c u l a r P o l a r i z a t i o n ( ) ) ;
64
PiApproximation.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Pi Approximation∗ 1−21−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <iostream>#inc lude <cmath>#inc lude ” Source . h”#inc lude ” Detector . h”#inc lude ”Photon . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Main∗ For t e s t i n g purposes . Should g ive an answer about equal∗ to p i .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/i n t main ( ){
long n = 1000 ;double d0 [ 3 ] = {1000 , 0 , 0} ;double s0 [ 3 ] = {0 , 0 , 0} ;double a = atan2 (1 , 1000) ∗ 180 / M PI ;Detector d( d0 , 0 , 180 , 90 , 270 , 1 . 0 ) ;Source s ( s0 , (90 − a ) , (90 + a ) , 360 − a , a ) ;f o r ( i n t i = 0 ; i < 4 ∗ n ; i++){
cout << i << endl ;Photon p = s . emit ( ) ;i f (d . detec ted (p , 1001 , f a l s e ) ){
d . setNumDetected (d . getNumDetected ( ) + 1 .0 / n ) ;}
}cout << d . getNumDetected ( ) << endl ;r e turn 0 ;
}
66
Point.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Point Header∗ 1−21−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f POINT H#d e f i n e POINT H
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Point Class∗ Cartes ian space po int .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s Point{
pub l i c :s t a t i c const i n t SIZE = 3 ; // dimensions o f space
p r i v a t e :double coord inate [ SIZE ] ;
pub l i c :Point ( ) ;Point ( double ∗ c ) ;Point ( const Point & p ) ;double getCoordinate ( i n t i ) const { re turn ( i >= 0 && i < SIZE ) ?
coord inate [ i ] : 0 ; } ; // get coord inate va luevoid setCoord inate ( i n t i , double n) { i f ( i >= 0 && i < SIZE )
coord inate [ i ] = n ; } ; // s e t coord inate valuedouble getDi s tance ( const Point & p) const ;double ca l cu l a t eAng l e ( const Point & p1 , const Point & p2 ) const ;void p r i n t ( ) const ;double operator [ ] ( i n t i ) { re turn coord inate [ i ] ; } ;void operator=(const Point & p ) ;
} ;#e n d i f
67
Point.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Point Class∗ 1−21−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <iostream>#inc lude <cmath>#inc lude ” Point . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Point∗ Set every coord inate to 0 .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Point : : Point ( ){
f o r ( i n t i = 0 ; i < SIZE ; i++){
se tCoord inate ( i , 0 ) ;}
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Point∗ Set every coord inate to match array c .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Point : : Point ( double ∗ c ){
f o r ( i n t i = 0 ; i < SIZE ; i++){
se tCoord inate ( i , c [ i ] ) ;}
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Point∗ Copy po int p .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Point : : Point ( const Point & p){
f o r ( i n t i = 0 ; i < SIZE ; i++){
68
se tCoord inate ( i , p . getCoordinate ( i ) ) ;}
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Distance∗ Get the d i s t anc e between the two po in t s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Point : : ge tDi s tance ( const Point & p) const{
double d = 0 ;f o r ( i n t i = 0 ; i < SIZE ; i++){
d += pow ( ( th i s−>getCoordinate ( i ) − p . getCoordinate ( i ) ) , 2 ) ;}re turn s q r t (d ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Calcu la te Angle∗ Get the ang le in degree s made by the two given po in t s∗ with t h i s po int as the ver tex . Use the law o f c o s i n e s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Point : : c a l cu l a t eAng l e ( const Point & p1 , const Point & p2 ) const{
double a = p1 . getDi s tance ( p2 ) ;double b = th i s−>getDi s tance ( p1 ) ;double c = th i s−>getDi s tance ( p2 ) ;i f ( a == 0 | | b == 0 | | c == 0){
re turn 0 ;}double r a t i o = (pow(b , 2) + pow( c , 2) − pow( a , 2 ) ) / (2 ∗ b ∗ c ) ;i f ( r a t i o > 1){
r a t i o = 1 . 0 ;}e l s e i f ( r a t i o < −1){
r a t i o = −1.0;}re turn acos ( r a t i o ) ∗ 180 / M PI ;
}
69
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Print∗ Print the va lue s o f the coo rd ina t e s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Point : : p r i n t ( ) const{
cout << ”(” << getCoordinate ( 0 ) ;f o r ( i n t i = 1 ; i < SIZE ; i++){
cout << ” ,” << getCoordinate ( i ) ;}cout << ” ) ” ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Equals∗ Copy po int p .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Point : : operator=(const Point & p){
f o r ( i n t i = 0 ; i < SIZE ; i++){
se tCoord inate ( i , p . getCoordinate ( i ) ) ;}
}
70
RandomSingleton.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Point Header∗ 2−12−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f RANDOM SINGLETON H#d e f i n e RANDOM SINGLETON H#inc lude <g s l / g s l r n g . h>us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Random S ing l e ton Class∗ Gives everyone r e l i a b l e random numbers .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s RandomSingleton{
p r i v a t e :g s l r n g ∗ rng ;RandomSingleton ( ) ;
pub l i c :˜RandomSingleton ( ) ;s t a t i c RandomSingleton & ge t In s tance ( ) { s t a t i c RandomSingleton in s t ance ;
r e turn in s t anc e ; } ;double rand ( ) ;double rand ( double max ) ;double rand ( double min , double max ) ;void seed ( unsigned long i n t seed ) ;
} ;#e n d i f
71
RandomSingleton.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Point Class∗ 2−12−2015∗ gs l rng mt19937 was s e l e c t e d over the other g s l rngs∗ becuase o f the long per iod f o r a g iven seed , and the∗ speed with which a new number can be acqu i red . Both o f∗ the se c h a r a c t e r i s t i c s are e s s e n t i a l in a Monte Carlo∗ s imu la t i on .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <sys / time . h>#inc lude <g s l / g s l r n g . h>#inc lude ”RandomSingleton . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Constructor∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/RandomSingleton : : RandomSingleton ( ){
rng = g s l r n g a l l o c ( gs l rng mt19937 ) ;t imeva l tv ;gett imeofday (&tv , NULL) ;unsigned long i n t seed = ( tv . t v s e c ∗ 1000) + ( tv . tv u s e c / 1000) ;g s l r n g s e t ( rng , seed ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Destructor∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/RandomSingleton : : ˜ RandomSingleton ( ){
g s l r n g f r e e ( rng ) ;}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Rand∗ Generate random number [ 0 , 1 ) .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double RandomSingleton : : rand ( ){
re turn g s l r n g u n i f o r m ( rng ) ;
72
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Rand∗ Generate random number [ 0 , max ) .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double RandomSingleton : : rand ( double max){
re turn max ∗ g s l r n g u n i f o r m ( rng ) ;}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Rand∗ Generate random number [ min , max ) .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double RandomSingleton : : rand ( double min , double max){
re turn (max − min ) ∗ g s l r n g u n i f o r m ( rng ) + min ;}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Seed∗ Seed us ing the g iven number .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void RandomSingleton : : seed ( unsigned long i n t seed ){
rng = g s l r n g a l l o c ( gs l rng mt19937 ) ;g s l r n g s e t ( rng , seed ) ;
}
73
Rayleigh.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Rayle igh Header∗ 2−5−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f RAYLEIGH H#d e f i n e RAYLEIGH H
#inc lude ”Medium . h”
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Rayle igh Class∗ This c l a s s s imu la t e s a medium f o r photons to pass∗ through . The photons undergo Rayle igh s c a t t e r i n g .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s Rayle igh : pub l i c Medium{
p r i v a t e :double d i s t r i b u t e ( double ang le ) const ;
pub l i c :Rayle igh ( ) : Medium ( ) {} ;Rayle igh ( Point po int ) : Medium( po int ) {} ;Rayle igh ( double ∗ coord inate ) : Medium( coord inate ) {} ;Rayle igh ( double rad iu s ) : Medium( rad iu s ) {} ;Rayle igh ( Point point , double rad iu s ) : Medium( point , r ad iu s ) {} ;Rayle igh ( double ∗ coord inate , double rad iu s ) : Medium( coord inate , r ad iu s )
{} ;Rayle igh ( const Medium & medium) : Medium(medium) {} ;v i r t u a l void s c a t t e r ( Photon &photon ) ;
} ;#e n d i f
74
Rayleigh.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Rayle igh Class∗ 2−5−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <iostream>#inc lude <cmath>#inc lude ” Rayle igh . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ D i s t r i b u t e∗ Given an ang le [ 0 , PI ) , i f a random number [ 0 , 1 ) i s g r e a t e r than∗ 2∗ cos ( ang le )ˆ2 then r e d i s t r i b u t e the ang le∗ to match that exact func t i on . Then return the ang le .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double Rayle igh : : d i s t r i b u t e ( double ang le ) const{
// i f a random number [ 0 , 1 ) i s l e s s than 2∗ cos ( ang le )ˆ2 , r e d i s t r i b u t e ang lei f ( getRS ( ) . rand ( ) > 2 ∗ pow( cos ( ang le ) , 2 ) ){
i f ( ang le > M PI / 2 . 0 ){
ang le += 2 ∗ ( 3 . 0 ∗ M PI / 4 .0 − ang le ) ;}e l s e{
ang le −= 2 ∗ ( ang le − M PI / 4 . 0 ) ;}
}re turn ang le ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Sca t t e r∗ This i s the ba s i c func t i on to change the v e l o c i t y , and∗ p o s s i b l y the f requency o f a g iven photon . Should c a l l∗ increment on the photon .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Rayle igh : : s c a t t e r ( Photon &photon ){
i f ( isInMedium ( photon . getLocat ion ( ) ) )
75
{// we need the v e l o c i t y o f the photondouble vx = photon . g e tVe l o c i t y ( ) . getCoordinate ( 0 ) ;double vy = photon . g e tVe l o c i t y ( ) . getCoordinate ( 1 ) ;double vz = photon . g e tVe l o c i t y ( ) . getCoordinate ( 2 ) ;// ang le that t h i s event w i l l r o t a t e and s c a t t e r the photon// pe rpend i cu la r to the d i r e c t i o n o f t r ave l , measured ccw// from the z−a x i s from the po int o f view o f the source o f the photondouble phi = getRS ( ) . rand ( ) ∗ 2 ∗ M PI ; // 0−2PI
// r e l a t i v e ang ledouble alpha = photon . ge tOr i en ta t i on ( ) ∗ M PI / 180 − phi ;i f ( alpha < 0){
alpha += 2 ∗ M PI ;}
// theta w i l l e i t h e r be i s o t r o p i c or notbool i s o t r o p i c = getRS ( ) . rand ( ) < (−cos (2 ∗ alpha ) / 2 + . 5 ) ;
// take acos o f t h i s ang le as a s c a l a r [−1 , 1 ] to get thetadouble beta = getRS ( ) . rand ( ) ∗ M PI ;i f ( ! i s o t r o p i c ){
beta = d i s t r i b u t e ( beta ) ;photon . s e t O r i e n t a t i o n ( getRS ( ) . rand (0 , 3 6 0 ) ) ;
// t h i s l i n e becomes important in the ca s e s o f c i r c u l a r p o l a r i z a t i o nphoton . setPhase ( 0 ) ;
}double theta = acos (2 ∗ beta / M PI − 1 ) ; // 0−PI and not uniform// tak ing the acos i s nece s sa ry even in the i s o t r o p i c case , because// we are us ing s p h e r e i c a l c oo rd ina t e s and we want the d i s t r i b u t i o n// at the p l o e s to have the same dens i ty and the d i s t r i b u t i o n at// the equatordouble a = vx ; // w i l l be ro ta ted to become the new vxdouble b = vy ; // w i l l be ro ta ted to become the new vydouble c = vz ; // w i l l be ro ta ted to become the new vzdouble d = −vy ; // componenet o f a x i s in the x−y planedouble e = vx ; // componenet o f a x i s in the x−y planei f ( vx == 0 && vy == 0) // s p e c i a l case when v i s only in the z d i r e c t i o n{
d = vz / abs ( vz ) ;}s e tRotate r (d , e , 0 ) ; // s e t an a x i s in the x−y plane , pe rpend i cu l a r to vr o t a t e r . r o t a t e ( a , b , c , theta ∗ 180 / M PI ) ; // r o t a t e by theta degree ss e tRotate r ( vx , vy , vz ) ; // s e t v as the a x i s o f r o t a t i o nr o t a t e r . r o t a t e ( a , b , c , phi ∗ 180 / M PI ) ; // r o t a t e by phi degree s
76
photon . s e t V e l o c i t y (0 , a ) ; // new vxphoton . s e t V e l o c i t y (1 , b ) ; // new vyphoton . s e t V e l o c i t y (2 , c ) ; // new vz// number o f s c a t t e r i n g events f o r the photon should be incremented// by onephoton . increment ( ) ;
}}
77
SimulateAtmosphere.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Simulate Atmosphere∗ 3−6−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <iostream>#inc lude <s t d l i b . h>#inc lude <cmath>#inc lude <sys / time . h>#inc lude ” Va l idat ionS imulat i on . h”#inc lude ”Atmosphere . h”#inc lude ” V i s i b l eSou r c e . h”#inc lude ” Detector . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Main∗ For t e s t i n g purposes .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/i n t main ( i n t argc , char ∗argv [ ] ){
double r = 100000;double d = r ∗ s q r t ( 3 ) ;double ps [ 3 ] = {−d , 0 , 0} ;double pa [ 3 ] = {0 , 0 , 0} ;double pd [ 3 ] = {d , 0 , 0} ;V i s i b l eSou r c e vs ( ps , 60 . 0 , 120 .0 , 330 .0 , 3 0 . 0 ) ;Atmosphere atm( pa , r ) ;Detector de t e c t o r (pd , 60 . 0 , 120 .0 , 150 .0 , 210 .0 , r ) ;i n t num = 1000 ;s t r i n g hostname ( getenv (”HOSTNAME” ) ) ;i f ( argc > 1){
num = a t o i ( argv [ 1 ] ) ;}ofstream fout , f , p ;i f ( argc > 2){
s t r i n g name( argv [ 2 ] ) ;f out . open ( ( name + ”−” + hostname + ” . out ” ) . c s t r ( ) ) ;f . open ( ( name + ”−” + hostname + ”− f . out ” ) . c s t r ( ) ) ;p . open ( ( name + ”−” + hostname + ”−p . out ” ) . c s t r ( ) ) ;
78
}e l s e{
f out . open ( ( hostname + ” . out ” ) . c s t r ( ) ) ;f . open ( ( hostname + ”− f . out ” ) . c s t r ( ) ) ;p . open ( ( hostname + ”−p . out ” ) . c s t r ( ) ) ;
}Val idat ionS imula t i on sim ( vs , detec tor , atm , num ) ;t imeva l tv ;gett imeofday (&tv , NULL) ;unsigned long i n t seed = ( tv . t v s e c ∗ 1000) + ( tv . tv u s e c / 1000) ;i n t o f f s e t = 0 ;f o r ( i n t i = 0 ; i < hostname . s i z e ( ) ; i++){
o f f s e t += pow(10 , i ) ∗ hostname [ i ] ;}sim . getRS ( ) . seed ( seed + o f f s e t ) ;sim . run ( fout ) ;f << sim . ge tFrequenc i e s ( ) . t oS t r i ng ( ) ;p << sim . g e t P o l a r i z a t i o n s ( ) . t oS t r i ng ( ) ;f out . c l o s e ( ) ;f . c l o s e ( ) ;p . c l o s e ( ) ;r e turn 0 ;
}
79
Simulation.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Simulat ion Header∗ 1−8−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f SIMULATION H#d e f i n e SIMULATION H
#inc lude <fstream>#inc lude ” Source . h”#inc lude ” Detector . h”#inc lude ”Photon . h”#inc lude ”Medium . h”#inc lude ”RandomSingleton . h”
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Simulat ion Class∗ This c l a s s runs a Monte Carlo s imu la t i on . The source∗ be pointed at or in the medium .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s S imulat ion{
protec ted :Source ∗ source ; // Source o f photonsDetector ∗ de t e c t o r ; // Detector o f photonsMedium ∗ medium ;unsigned long i n t numIterat ions ;s t r i n g header ;v i r t u a l s t r i n g format ( const Photon & photon ) ;
pub l i c :S imulat ion ( Source & source , Detector & detector , Medium & medium ,
unsigned long i n t numIterat ions , s t r i n g header = ””){ th i s−>source = &source ; th i s−>de t e c t o r = &det e c t o r ;
th i s−>medium = &medium ; th i s−>numIterat ions = numIterat ions ;th i s−>header = header ; } ;
Source & getSource ( ) { re turn ∗ source ; } ;Detector & getDetector ( ) { re turn ∗ de t e c t o r ; } ;Medium & getMedium ( ) { re turn ∗medium ; } ;unsigned long i n t getNumIterat ions ( ) { re turn numIterat ions ; } ;s t a t i c RandomSingleton & getRS ( )
{ re turn RandomSingleton : : g e t In s tance ( ) ; } ;void setNumIterat ions ( unsigned long i n t numIterat ions )
80
Simulation.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Simulat ion Class∗ 2−27−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <iostream>#inc lude <cmath>#inc lude <sstream>#inc lude ” Simulat ion . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Format∗ Format the data f o r gnuplot . In t h i s scope you have∗ a c c e s s to the photon be f o r e i t was detected , the∗ detector , medium , and source .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/s t r i n g Simulat ion : : format ( const Photon & photon ){
re turn photon . t oS t r i ng ( ) ;}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Run∗ Run the s imu la t i on .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void Simulat ion : : run ( ofstream & fout ){
Photon photon ;double d i s t anc e ;double f r e e D i s t a n c e ;long double percent = numIterat ions / 9 9 . 0 ;i n t x = −1;f out << header << endl ;f o r ( i n t i = 0 ; i < numIterat ions ; i++){
photon = getSource ( ) . emit ( ) ; // new photond i s t anc e = photon . getLocat ion ( ) . ge tDi s tance (
getMedium ( ) . getLocat ion ( ) ) + . 0 1 ;whi l e ( ! getMedium ( ) . isInMedium ( photon . getLocat ion ( ) ) &&
photon . getLocat ion ( ) . ge tDi s tance (getMedium ( ) . getLocat ion ( ) ) < d i s t anc e )
82
{// get to the edge fo the medium
d i s t anc e = photon . getLocat ion ( ) . ge tDi s tance (getMedium ( ) . getLocat ion ( ) ) ;
photon . advance (d i s t anc e − getMedium ( ) . getRadius ( ) ∗ . 9999 , f a l s e ) ;
}whi le ( getMedium ( ) . isInMedium ( photon . getLocat ion ( ) ) ){
// whi l e we are in the medium// get f r e e d i s t ance
f r e e D i s t a n c e = getMedium ( ) . getFreeDis tance ( photon ) ;// photon detec ted
i f ( ge tDetector ( ) . de tec ted ( photon , f r e eD i s tance , f a l s e ) ){
f out << format ( photon ) << endl ; // format and output the r e s u l t// end the whi l e loop
photon . advance ( getMedium ( ) . getRadius ( ) ∗ 2 , f a l s e ) ;}e l s e // photon not detec ted{
photon . advance ( f r e eD i s tance , f a l s e ) ; // advance photon// s t i l l in medium
i f ( getMedium ( ) . isInMedium ( photon . getLocat ion ( ) ) ){
getMedium ( ) . s c a t t e r ( photon ) ; // s c a t t e r photon}e l s e i f ( ge tDetector ( ) . de tec ted ( photon , photon . getLocat ion ( )
. ge tDi s tance ( getDetector ( ) . getLocat ion ( ) ) , f a l s e ) ){
// check f o r the case that the de t e c t o r// i s ou t s i d e the medium but that the// photon i s headed s t r a i g h t towards i t// format and output the r e s u l t
f out << format ( photon ) << endl ;}
}}i f ( ( double ) i / percent > x ) // output s t a t u s{
whi le ( ( double ) i / percent > x ){
x++;}
83
SolidAngle.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ S o l i d Angle Header∗ 1−21−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f SOLID ANGLE H#d e f i n e SOLID ANGLE H
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ S o l i d Angle Class∗ An angle with an upper and lower range . Everything i s in∗ degree s . I f i sFu l lAng l e i s s e t to f a l s e then that means∗ that the ranges are a l l bound [ 0 , 1 8 0 ) . I f min i s g r e a t e r∗ numer i ca l ly than max then the v a l i d range wraps around∗ from min to max .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s So l idAngle{
p r i v a t e :s t a t i c const double FULL = 3 6 0 . 0 ;s t a t i c const double HALF = 1 8 0 . 0 ;bool i sFu l lAng l e ;double min ;double max ;double reduce ( double n) const ;
pub l i c :So l idAngle ( )
{ i sFu l lAng l e = true ; setMin ( 0 ) ; setMax ( .999999 ∗ FULL ) ; } ;So l idAngle ( bool i sFu l lAng l e )
{ th i s−>i sFu l lAng l e = i sFu l lAng l e ; setMin ( 0 ) ;setMax ( ( i sFu l lAng l e ) ? .999999 ∗ FULL : .999999 ∗ HALF) ; } ;
So l idAngle ( double min , double max){ i sFu l lAng l e = true ; setMin ( min ) ; setMax (max ) ; } ;
So l idAngle ( double min , double max , bool i sFu l lAng l e ){ th i s−>i sFu l lAng l e = i sFu l lAng l e ; setMin ( min ) ; setMax (max ) ; } ;
So l idAngle ( const So l idAngle & so l idAng l e ){ i sFu l lAng l e = so l i dAng l e . i sFu l lAng l e ;setMin ( so l i dAng l e . getMin ( ) ) ; setMax ( so l i dAng l e . getMax ( ) ) ; } ;
double getMin ( ) const { re turn min ; } ;double getMax ( ) const { re turn max ; } ;double getRange ( ) const ;void setMin ( double n ) ;
85
void setMax ( double n ) ;bool isInRange ( double n) const ;void p r i n t ( ) const ;
} ;#e n d i f
86
SolidAngle.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ S o l i c Angle Class∗ 1−21−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <iostream>#inc lude ” Sol idAngle . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Reduce∗ Put the ang le in the range [0−360).∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double So l idAngle : : reduce ( double n) const{
whi le (n < 0){
n += FULL;}whi le (n >= FULL){
n −= FULL;}re turn n ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Range∗ Get the magnitude o f the v a l i d range .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/double So l idAngle : : getRange ( ) const{
i f ( min <= max){
re turn max − min ;}e l s e{
re turn ( i sFu l lAng l e ) ? (FULL − min + max) : (HALF − min + max ) ;}
}
87
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Set Min∗ Set minimum angle ( does not have to be l e s s than max∗ ang le ) .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void So l idAngle : : setMin ( double n){
n = reduce (n ) ;i f ( i sFu l lAng l e | | n < HALF){
min = n ;}e l s e{
min = FULL − n ;}
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Set Max∗ Set maximum angle ( does not have to be more than min∗ ang le ) .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void So l idAngle : : setMax ( double n){
n = reduce (n ) ;i f ( i sFu l lAng l e | | n < HALF){
max = n ;}e l s e{
max = FULL − n ;}
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ I s In Range∗ Return true i s the g iven ang le i s with in the s o l i d ang le .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/bool So l idAngle : : i s InRange ( double n) const{
88
n = reduce (n ) ;i f ( min <= max){
re turn n >= min && n <= max ;}e l s e i f ( ! i sFu l lAng l e && n >= HALF){
n = FULL − n ;}re turn ! ( n > min && n < max ) ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Print∗ Print the va lue s o f the coo rd ina t e s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/void So l idAngle : : p r i n t ( ) const{
cout << ” [” << min << ” ,” << max << ” ] ” ;}
89
Source.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Source Header∗ 1−21−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f SOURCE H#d e f i n e SOURCE H
#inc lude ”Photon . h”#inc lude ” Point . h”#inc lude ” Sol idAngle . h”#inc lude ”RandomSingleton . h”
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Source Class∗ This c l a s s s imu la t e s a source o f l i g h t .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s Source{
p r i v a t e :Point l o c a t i o n ;So l idAngle theta ; //0 to p iSo l idAngle phi ; //0 to 2 p i
pub l i c :Source ( ) : l o c a t i o n ( ) , theta ( f a l s e ) , phi ( t rue ) {} ;Source ( double ∗ coord inate , double thetaMin , double thetaMax ,
double phiMin , double phiMax ) ;Source ( const Source & source ) : l o c a t i o n ( source . getLocat ion ( ) ) ,
theta ( source . getTheta ( ) ) , phi ( source . getPhi ( ) ) {} ;Point getLocat ion ( ) const { re turn l o c a t i o n ; } ; // get the l o c a t i o nSol idAngle getTheta ( ) const { re turn theta ; } ; // get the v e r t i c a l ang leSo l idAngle getPhi ( ) const { re turn phi ; } ; // get the h o r i z o n t a l ang lePoint g e tVe l o c i t y ( ) ;s t a t i c RandomSingleton & getRS ( )
{ re turn RandomSingleton : : g e t In s tance ( ) ; } ;void s e tLoca t i on ( i n t min , double max) { theta . setMin ( min ) ;
theta . setMax (max ) ; } ;void setTheta ( double min , double max) { theta . setMin ( min ) ;
theta . setMax (max ) ; } ;void setPhi ( double min , double max) {phi . setMin ( min ) ; phi . setMax (max ) ; } ;v i r t u a l Photon emit ( ) ;
} ;
90
Source.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Source Class∗ 1−21−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <iostream>#inc lude <cmath>#inc lude ” Source . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Source∗ I n i t i a l i z e everyth ing . Phi must be a f u l l angle , and∗ theta a h a l f ang le .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Source : : Source ( double ∗ coord inate , double thetaMin , double thetaMax ,
double phiMin , double phiMax ) : theta ( thetaMin , thetaMax , f a l s e ) ,phi ( phiMin , phiMax , t rue )
{f o r ( i n t i = 0 ; i < Point : : SIZE ; i++){
l o c a t i o n . se tCoord inate ( i , coo rd inate [ i ] ) ;}
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Get Ve loc i ty∗ Generate the v e l o c i t y o f the g iven photon .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Point Source : : g e tVe l o c i t y ( ){
Point v e l o c i t y ;double t , p ;i f ( theta . getMin ( ) <= theta . getMax ( ) ){
t = theta . getMin ( ) + theta . getRange ( ) ∗ getRS ( ) . rand ( ) ;}e l s e{
t = theta . getMin ( ) − theta . getRange ( ) ∗ getRS ( ) . rand ( ) ;}p = phi . getMin ( ) + phi . getRange ( ) ∗ getRS ( ) . rand ( ) ;
92
v e l o c i t y . s e tCoord inate (0 , cos (p ∗ M PI / 180) ∗ s i n ( t ∗ M PI / 1 8 0 ) ) ;v e l o c i t y . s e tCoord inate (1 , s i n (p ∗ M PI / 180) ∗ s i n ( t ∗ M PI / 1 8 0 ) ) ;v e l o c i t y . s e tCoord inate (2 , cos ( t ∗ M PI / 1 8 0 ) ) ;r e turn v e l o c i t y ;
}
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Emit∗ Generate a photon with a l l o f the r i g h t c h a r a c t e r i s t i c s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Photon Source : : emit ( ){
Photon photon ( getLocat ion ( ) , g e tVe l o c i t y ( ) , 100 , getRS ( ) . rand (360) ,getRS ( ) . rand (360) , getRS ( ) . rand ( 3 6 0 ) ) ;
r e turn photon ;}
93
ValidationSimulation.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Val idat i on Simulat ion Header∗ 3−18−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f VALIDATION SIMULATION H#d e f i n e VALIDATION SIMULATION H
#inc lude ” Simulat ion . h”#inc lude ”Histogram . h”
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Val idat i on Simulat ion Class∗ This c l a s s runs a Monte Carlo s imu la t i on . I t v a l i d a t e s∗ the model f o r s imple r a y l e i g h s c a t t e r i n g in∗ the atmosphere .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s Va l idat ionS imulat i on : pub l i c S imulat ion{
protec ted :Histogram f r e q u e n c i e s ;Histogram p o l a r i z a t i o n s ;v i r t u a l s t r i n g format ( const Photon & photon ) ;
pub l i c :Va l idat ionS imula t i on ( Source & source , Detector & detector ,
Medium & medium , unsigned long i n t numIterat ions ) :S imulat ion ( source , detec tor , medium , numIterat ions ) ,f r e q u e n c i e s (1000 , 3 .89 e11 , 400 .0 e12 ) , p o l a r i z a t i o n s (360 , 1 , 0){header = ” Source−ang le Frequency” +” Relat ive−P o l a r i z a t i o n Z−approach Z−l i n e a r−p o l a r i z a t i o n ” ; } ;
Histogram getFrequenc i e s ( ) const { re turn f r e q u e n c i e s ; } ;Histogram g e t P o l a r i z a t i o n s ( ) const { re turn p o l a r i z a t i o n s ; } ;
} ;#e n d i f
94
ValidationSimulation.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ Val idat i on Simulat ion Class∗ 3−18−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude <iostream>#inc lude <cmath>#inc lude <sstream>#inc lude ” Va l idat ionS imulat i on . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Format∗ Format the data f o r gnuplot . Should output ” Source−ang le∗ Frequency Relat ive−P o l a r i z a t i o n Z−approach∗ Z−l i n e a r−p o l a r i z a t i o n ”∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/s t r i n g Va l idat ionS imula t i on : : format ( const Photon & photon ){
s t r i ng s t r eam data ;Point p = photon . getLocat ion ( ) ; // photonPoint c = getDetector ( ) . getLastContact ( ) ; // contactPoint s = getSource ( ) . getLocat ion ( ) ; // sourcedouble angleFromSource = c . ca l cu l a t eAng l e (p , s ) ; // ang le pcsdouble angleFromZ ;i f ( angleFromSource < 0 . 1 ) // case o f a l l unscat te red photons{
angleFromZ = 0 ;}e l s e{
// from s to cdouble sc [ 3 ] = {c . getCoordinate (0 ) − s . getCoordinate ( 0 ) ,
c . getCoordinate (1 ) − s . getCoordinate ( 1 ) ,c . getCoordinate (2 ) − s . getCoordinate ( 2 ) } ;
Rotation r = getMedium ( ) . getRotater ( ) ;// s e t a x i s o f r o t a t i o n to z−a x i sr . s e tAx i s (0 , 0 ) ;r . s e tAx i s (1 , 0 ) ;r . s e tAx i s (2 , 1 ) ;
// from s to pdouble sp [ 3 ] = {p . getCoordinate (0 ) − s . getCoordinate ( 0 ) ,
95
p . getCoordinate (1 ) − s . getCoordinate ( 1 ) ,p . getCoordinate (2 ) − s . getCoordinate ( 2 ) } ;
// f o r c a l c u l a t i n g the ang l e s to r o t a t e sp such that sc would be// on the x−a x i s
double d = s q r t (pow( sc [ 0 ] , 2) + pow( sc [ 1 ] , 2 ) ) ;// z−a x i s r o t a t i o n
r . r o t a t e ( sp [ 0 ] , sp [ 1 ] , sp [ 2 ] , −atan2 ( sc [ 1 ] , s c [ 0 ] ) ∗ 180 / M PI ) ;// s e t a x i s o f r o t a t i o n to y−a x i sr . s e tAx i s (0 , 0 ) ;r . s e tAx i s (1 , 1 ) ;r . s e tAx i s (2 , 0 ) ;
// y−a x i s r o t a t i o nr . r o t a t e ( sp [ 0 ] , sp [ 1 ] , sp [ 2 ] , atan2 ( sc [ 2 ] , d ) ∗ 180 / M PI ) ;angleFromZ = ( atan2(−sp [ 1 ] , sp [ 2 ] ) ∗ 180 / M PI + 1 8 0 ) ;
}// o r i e n t a t i o n − ang le o f i n c i d e n c e from z−a x i sdouble r e l a t i v e P o l a r i z a t i o n = photon . ge tOr i en ta t i on ( ) − angleFromZ ;i f ( r e l a t i v e P o l a r i z a t i o n < 0){
r e l a t i v e P o l a r i z a t i o n += 360 ;}i f ( angleFromSource >= 0 . 1 ){
f r e q u e n c i e s << photon . getFrequency ( ) ;}i f ( angleFromSource >= 45 && angleFromSource < 46){
p o l a r i z a t i o n s << r e l a t i v e P o l a r i z a t i o n ;}data << angleFromSource << ” ” << photon . getFrequency ( ) << ” ”<< r e l a t i v e P o l a r i z a t i o n << ” ” << angleFromZ << ” ”
<< photon . g e tOr i en ta t i on ( ) ;r e turn data . s t r ( ) ;
}
96
VisibleSource.h
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ V i s i b l e Source Header∗ 3−2−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#i f n d e f VISIBLE SOURCE H#d e f i n e VISIBLE SOURCE H
#inc lude ” Source . h”
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ V i s i b l e Source Class∗ This c l a s s s imu la t e s a source o f v i s i b l e l i g h t . The∗ emitted photons are incoherent , have random ( l i n e a r )∗ p o l a r i z a t i o n , and a evenly d i s t r i b u t e d random frequency∗ [ 400 THz, 789 THz ) .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/c l a s s V i s i b l eSou r c e : pub l i c Source{
pub l i c :V i s i b l eSou r c e ( ) {} ;V i s i b l eSou r c e ( double ∗ coord inate , double thetaMin , double thetaMax ,
double phiMin , double phiMax ) : Source ( coord inate , thetaMin ,thetaMax , phiMin , phiMax ) {} ;
V i s i b l eSou r c e ( const Source & source ) : Source ( source ) {} ;v i r t u a l Photon emit ( ) ;
} ;#e n d i f
97
VisibleSource.cpp
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ James Nelson∗ V i s i b l e Source Class∗ 3−2−2015∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/#inc lude ” V i s i b l eSou r c e . h”us ing namespace std ;
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Emit∗ Generate a photon with a l l o f the r i g h t c h a r a c t e r i s t i c s .∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/Photon V i s i b l eSou r c e : : emit ( ){
Photon photon ( getLocat ion ( ) , g e tVe l o c i t y ( ) , getRS ( ). rand (400 . 0 e12 , 789 .0 e12 ) , getRS ( ) . rand (360) ,
getRS ( ) . rand (360) , 0 ) ;r e turn photon ;
}
98