Transcript Earth’s Tides Simulation

Earth’s Tides Simulation
Craig Brubaker
Union College
2/28/04
Agenda
• Introduction
–
–
–
–
Purpose
Tidal Force
Tidal Bulges
Orbits
• Simulation Overview
– Inputs
– Outputs
– Example Simulation Configurations
• Under the hood
– Classes
– Code Snapshots
• Additional Work (features excluded)
Purpose of the Project
To produce an application that helps students
understand the tidal forces and the effects of
orbital cycles on the tidal forces.
To be used especially as a demonstration for
introductory level courses.
Simplifications of real system:
• Assume Earth covered by a shallow ocean.
• Parts of the system should be able to be turned
on and off.
Tidal Force
Recall Force of Gravity:
• Proportional to the product of the masses
over the square of the distance.
Tidal Force:
• Proportional to the product of the masses
over the CUBE of the distance.
Laws of gravity and tides
The gravitational attraction between two bodies is determined by
Newton’s law of gravitation:
A = gravitational attractive force.
m1 and m2 = masses of the bodies attracting each other.
r = distance between the centers of the two bodies.
G = the gravitational constant.
The tide generating force is derived from Newton’s law. This force is
related to the difference between the gravitational attraction at Earth’s
center and surface.
F = the effective tidal force.
 = proportional to.
Major tidal influences on Earth
Though much more massive than the moon, the sun is so
much farther away that its tidal influence is less than half.
Mass
Distance
Tidal effect
Sun
2.0*1033 g
150,000,000 km
0.46
Moon
7.3*1025 g
385,000 km
1.00
Tidal Bulge
• Tidal Bulge
– Tidal Force produces TWO high tide points.
• Point on Earth closest to orbital body.
• Point on Earth farthest from orbital body.
– Tidal Force produces a low tide line equidistant
to both high tide points.
– The greater the high tide points, the lesser the
low tide line.
• Interaction of lunar and solar tides
– At any point it is a simple sum.
Gravitational tidal bulge
If we pretend that the moon does not orbit the Earth, gravitational
attraction would raise a tidal bulge directed toward the moon.
© Kurt Hollocher, 2002
The gravitational forces are directed exactly toward the moon’s center.
Earth-moon
system: resultant
forces on Earth’s
surface
The centrifugal and
gravitational tidal vectors are
shown resolved over the
Earth’s surface. The vectors
show that water is drawn into
the tidal bulges, reaching
maximum bulge elevation at
points nearest and farthest
from the moon. The lower
diagram shows how, in a
simple-minded model, two
low and two high tides are
expected daily.
Earth-sun-moon system: tide systematics
Recall that the tidal bulges are identical on the sides of the Earth facing
or opposite the moon. The same is true of the tides raised by the sun,
except the solar tides are only ~46% as large as those of the lunar tides.
Orbits
• Kepler’s Laws of Planetary Motion
I. The orbits of the planets are ellipses,
with the Sun at one focus of the ellipse.
Orbits
• Kepler’s Laws of Planetary Motion
II. The line joining the planet to the Sun
sweeps out equal areas in equal times
as the planet travels around the ellipse.
Orbits
• Kepler’s Laws of
Planetary Motion
III. The ratio of the
squares of the
revolutionary
periods for two
planets is equal to
the ratio of the
cubes of their
semimajor axes:
Ellipticity of Earth and moon orbits
The orbits of the moon around Earth and of the Earth around the sun are
ellipses. The Earth-moon orbital distance varies from 375,200 to 405,800
km, so the lunar tidal effect varies by 11.8% over a lunar month (inverse
cube law, remember). The Earth-sun distance varies from 148,500,000 to
152,200,000 km, so the solar tidal effect varies by 3.7% over a year.
Simulation
Overview
• Inputs
– EARTH ORBIT(in hours 0 to
8760):
• 24 hours * 365 days
– LUNAR ORBIT(in hours 0 to
708):
• 24 hours * 29.5 days
– Turn on/off (for Earth orbit and
Lunar orbit)
– Update orbits to entered orbit
time values (again, for both)
– Input sets
– Advance by day or hour
Simulation
Overview
• Outputs
– Tidal display
• Displays resulting tide
levels (tidal bulges)
• Blue (low tide)  Green
 Red (high tide)
– %DISPLACEMENT
• Orbiting body goes from a
minimum distance to a
maximum distance.
• %DISPLACEMENT is the
percent distance that the
orbiting body is from its
minimum distance.
– Orbit times (for both)
Example(1a)
Overlapping solar and
lunar tides at
maximum
magnitudes
Example(1b)
Overlapping solar and
lunar tides at
maximum
magnitudes
Turn OFF Earth orbit
Update Earth
Example(1c)
Overlapping solar and
lunar tides at
maximum
magnitudes
Turn OFF lunar orbit
Update Moon
Example(2a)
Solar and lunar tidal
forces at right
angles.
Example(2b)
Solar and lunar tidal
forces at right
angles.
Turn OFF Earth orbit
Example(2c)
Solar and lunar tidal
forces at right
angles.
Turn OFF lunar orbit
Example(3a)
Input Set Two
Example(3b)
Input Set Two
ADVANCE DAY 3
times (or add 72 to
orbit inputs and
update each).
Example(3c)
Input Set Two
ADVANCE DAY 6
times (or add 144 to
orbit inputs and
update each).
Example(3d)
Input Set Two
ADVANCE DAY 9
times (or add 216 to
orbit inputs and
update each).
Under the hood
• Java applet created in BlueJ:
• Classes:
Under the hood
– EarthTides (applet)
• Buttons, labels, event handling
• start method, paint method
– Sun
• Polar coordinates to Sun – geocentric: Earth at (0,0,0), rotate the Sun
• Get magnitude of solar force
• Advance function – geocentric: rotate the Sun
– Moon
• As Sun class, but for moon
• Advance function: accounts for inclination of orbital plane
– Pcoords
• Polar coordinates: 2 directions and a distance
– EarthPoint
• Contains the directions that correspond to this point on the Earth and
the magnitude of the tide.
– Testing classes
• TestSun, TestStart, TestPaint, RectTest.
Sun’s advance method (1)
/**
* advance method - advances the position of the Sun (geocentric) by hours
* many hours.
*
* @param hours the amount of time to advance in hours
*/
public void advance(int hours)
{
double degMove = 360.0/(MAXTIMEEO + 1); // degrees to move each hour
while ((hours > 0) && (orbitOn)) {
// advance position for 1 hour
if(timeEO == MAXTIMEEO)
coords.dir1 = 0; // reset to correct small fraction that crops up
else if( (coords.dir1 + degMove) < 360 )
coords.dir1 += degMove;
else
coords.dir1 = (coords.dir1 - 360) + degMove;
coords.dist = MINDIST +
(Math.sin(Math.toRadians((coords.dir1/2.0))) * (MAXDIST-MINDIST));
timeEO++;
if(timeEO > MAXTIMEEO) timeEO = 0;
hours--;
}
}
Sun’s advance method (2)
• Approximation:
for each time interval the change in angle that the
Earth makes with the Sun (DegMove) is the same.
– Accuracy?
• The distance between the Earth and Sun is inversely
proportional to the change in angle that the Earth makes with
the Sun in a given time interval.
• Recall Kepler’s 2nd law: equal areas swept in equal times.
• MAXIMUM_DISTANCE = 152,104,980 km
• MINIMUM_DISTANCE = 147,085,800 km.
• % difference between distances =
(MAXIMUM_DISTANCE - MINIMUM_DISTANCE
/MAXIMUM_DISTANCE) * 100%
=
3.29 %
Moon’s advance method
/**
* advance method - advances the position of the Sun (geocentric) by hours
* many hours.
*
* @param hours the amount of time to advance in hours
*/
public void advance(int hours)
{
double degMove = 360.0/(MAXTIMEMO + 1); // degrees to move each hour
while ((hours > 0) && (orbitOn)) {
// advance position for 1 hour
if(timeMO == MAXTIMEMO)
coords.dir1 = 0; // reset to correct small fraction that crops up
else if( (coords.dir1 + degMove) < 360 )
coords.dir1 += degMove;
else
coords.dir1 = (coords.dir1 - 360) + degMove;
coords.dir2 = ORBITINCLINATION * Math.sin(Math.toRadians(coords.dir1));
if(coords.dir2 < 0)
coords.dir2 += 360;
coords.dist = MINDIST +
(Math.sin(Math.toRadians((coords.dir1/2.0))) * (MAXDIST-MINDIST));
timeMO++;
if(timeMO > MAXTIMEMO) timeMO = 0;
hours--;
}
}
// determine which points to draw and assign corresponding directions
pointSize = 5; // the size in pixels of each dimension for a point,
// so pointSize = 5 represents 5x5 pixels
double radius = 50; // circle's radius is radius # points long
double i = 0; // holds a shifted coordinate value
double j = 0; // holds an angle, which may need to be made positive
for(int x = 0; x < 100; x++)
for(int y = 0; y < 100; y++) { // for each possible point
// if this point is part of the filled circle to draw
//
note: distance = sqrt(deltax^2 + deltay^2),
//
and circle center has coordinates (49.5,49.5)
if(Math.sqrt(Math.pow(49.5-x,2) + Math.pow(49.5-y,2)) <= radius)
{
points[x][y].tideMag = 0; // include this one
// calculate dir1:
// leftmost x is 270 degrees, center is 0, rightmost is 90
i = x - 49.5;
j = Math.toDegrees(Math.asin(i/49.5));
if (j >= 0)
points[x][y].dir1 = j;
else points[x][y].dir1 = 360 + j;
// calculate dir2:
// top y is 90, center is 0, bottom is 270 degrees
i = y - 49.5;
j = Math.toDegrees(Math.asin(i/49.5));
if (j > 0)
points[x][y].dir2 = 360 - j;
else points[x][y].dir2 = -1 * j;
}
else points[x][y].tideMag = -1; // discard this one
}
Part of
EarthTides start()
method
EarthTides paint method (1)
/**
* paint - paints the tidal display area.
*
*/
public void paint(Graphics g) {
super.paint(g); // removes flicker effect
for(int x = 0; x < 100; x++)
for(int y = 0; y < 100; y++) {
if(points[x][y].tideMag >= 0) { // if point is within filled circle
// calculate tide magnitude for point[x][y]
points[x][y].tideMag = 0;
double deltaDir1 = 0;
double deltaDir2 = 0;
double angDist = 0;
EarthTides paint method (2)
// solar tide
// calculate change in each direction
if (Math.abs(sun.coords.dir1 - points[x][y].dir1) <= 180)
deltaDir1 = Math.abs(sun.coords.dir1 - points[x][y].dir1);
else // look the other way
deltaDir1 = 360 Math.abs(sun.coords.dir1 - points[x][y].dir1);
if (Math.abs(sun.coords.dir2 - points[x][y].dir2) <= 180)
deltaDir2 = Math.abs(sun.coords.dir2 - points[x][y].dir2);
else // look the other way
deltaDir2 = 360 Math.abs(sun.coords.dir2 - points[x][y].dir2);
// currect for deltaDir's that are too large
if(deltaDir1 >= 90)
deltaDir1 = 180 - deltaDir1;
if(deltaDir2 >= 90)
deltaDir2 = 180 - deltaDir2;
// angDist: angular distance to solar high tide
angDist =
Math.sqrt(Math.pow(deltaDir1,2) + Math.pow(deltaDir2,2));
// if angDist = 0 or 180, at a high tide point
// if angDist = 90 or 270, at a low tide point
points[x][y].tideMag += ( sun.getRelMag() *
((Math.cos(Math.toRadians(angDist*2)) + 1) / 2) );
EarthTides paint method (3)
// lunar tide
… similar to solar tide calculation
// select color
double mag = (int)points[x][y].tideMag;
int red,green,blue = 0;
if (mag < 500) {
red = 0;
blue = (int)(((500-mag)/500) * 255);
green = (int)((mag/500) * 255);
}
else {
red = (int)(((mag-500)/500) * 255);
blue = 0;
green = (int)(((1000/mag)-1) * 255);
}
theColor = new Color(red,green,blue);
// draw the point
g.setColor(theColor);
g.fillRect(x*(pointSize), (y*(pointSize)) + OFFSET,
pointSize, pointSize);
Additional Work
• Moon’s precessions
– Precession of the lunar orbital ellipse = 8.93 years.
– Precession of the lunar orbital plane = 18.6 years.
• Point Tracking
– User selects a point on the Earth and the system
dynamically displays a graph of the tidal level at that
point.
– Impact: until now, spin of the Earth not necessary.
• The tidal bulge would look the same from a fixed view angle if
the Earth spun or not.
• Multiple View angles
– Current simulation has only one.
The End.