Thursday, 8 October 2009

jupiter - How to calculate conjunctions of 2 planets

EDIT: http://wgc.jpl.nasa.gov:8080/webgeocalc/#AngularSeparationFinder lets you find planetary conjunctions online using NASA's data. It's still iterative, but fairly fast (since NASA uses fairly powerful servers, even for their websites).



Summary: I'm still researching, but there appears to be no well-known,
reliable non-iterative method to find conjunctions. Using the
iterative method and the C SPICE libraries, I created a table of
conjunctions for the visible planets (Mercury, Venus, Mars, Jupiter,
Saturn, Uranus) here:



http://search.astro.barrycarter.info/



Full "answer":



I am still researching a general answer to this question ("How to
calculate conjunctions of 2 planets"), but here's what I have so far.



The iterative method:



  • Compute the positions of the planets at regular intervals (eg,
    daily). The "daily" works for planets (but not some asteroids and
    definitely not the Moon) because the planets move through the sky
    relatively slowly.


  • Find local minima in the daily lists.


  • For efficiency, carefully discard local minima that are too
    large. For example, Mercury and Venus may approach each other, reach
    a minimal distance of 20 degrees, and then drift apart. The 20
    degrees is a local minima, but not a conjunction.


  • However, be careful when discarding minima. If you are searching
    for 5-degree conjunctions, two planets may be 5.1 degrees apart one
    day, and 5.2 degrees apart the next day, but less than 5 degrees
    apart sometime in the interim.


  • For 5-degree conjunctions, you only need daily minima less than 8
    degrees, and even that is overkill. The fastest a planet can move in
    the sky is 1.32 degrees per day (Mercury), and the second fastest is
    1.19 degrees per day (Venus). In theory, these movements could be in
    opposite directions, so the fastest two planets can separate is 2.51
    degrees per day. So, if two planets are more than 8 degrees apart
    two days in a row, there is no way they could be closer than 5
    degrees between the days.


  • In reality, planets maximum retrograde angular speed is slower
    than the prograde maximum speed, so the 2.51 degree limit above is
    never actually reached.


  • After finding local minima, use minimization techniques (eg, the
    ternary method) to find the instant of closest approach.


  • I ended up using the C SPICE libraries, and found 32,962
    six-degrees-or-less conjunctions between -13201 and 17190, averaging
    about 1 conjunction per year. Of these, 2,185 occur between the "star
    of Bethlehem" and the 2015 conjunctions:


http://f97444b55127cb9d21fd365807cad442.astro.db.mysql.94y.info/




This iterative process works, but can be tedious. Since planetary
positions are semi-well-behaved, you'd think there would be a faster,
non-iterative method. Well...



http://emfisis.physics.uiowa.edu/Software/C/cspice/doc/html/cspice/gfsep_c.html



However, this also uses an iterative method, as the long description
of the "step" parameter indicates:



"step must be short enough for a search using step to locate the time
intervals where the specified angular separation function is monotone
increasing or decreasing. However, step must not be too short, or
the search will take an unreasonable amount of time"



By experimentation, I found that a step size of 6 days does not find
all Mercury/Venus minimal separations, although a step size of 1 day
does find these. In other words, reducing the step size from 6 days to
1 day found additional conjunctions, but reducing the step size to
well below 1 day did not produce any additional conjunctions.




M[y script] iterates through dates.



[...]



In Astronomical Algorithms, Meeus has a chapter (17) on Planetary
Conjunctions, but the chapter is less than three pages and lacks
detail except that he's pretty clearly iterating and looking for
the smallest separation, same as my Python program does.



He does a little better in Astronomical Formulae for Calculators:
sounds like he's advocating iterating over big steps to find the
place where the separation stops decreasing and starts increasing,
then using "inverse interpolation" to find the exact time.



"Mathematical Astronomy Morsels" (also Meeus) talks starting on p.
246 about triple conjunctions (defined as two planets having several
conjunctions in a short time, due to retrograde motion, not three
planets all in conjunction at once) and gives some examples for very
specific pairs, like Jupiter and Saturn, with ways you could look for
those conjunctions.



It doesn't look like any of these books would be very helpful in
finding a non-iterative solution.



  • I haven't had a chance to read the books above, but did find:

http://adsabs.harvard.edu/abs/1981JRASC..75...94M



where Meeus confirms the standard iterative method, but also provides
a different, less accurate method. Unfortunately, Meeus only uses this
method to compute solar conjunctions, elongations and oppositions, not
interplanet conjunctions.



  • Jon Giorgini of NASA (jdg@tycho.jpl.nasa.gov) tells me:



As far as NASA computed planetary/stellar conjunctions/occultations, I
don't know of anyone within NASA that does that routinely. There is an
external network of volunteers that does that under the umbrella of
the International Occultation Timing Association (IOTA), and they have
developed pretty refined internal software for that purpose.





[...] the software package Occult does generate planetary conjunction
predictions - based on a two-body solution. The approach used is a
crude brute-force method of generating the planetary ephemerides on a
daily basis. It is not particularly efficient - but it is sufficient
for its intended purpose. [...]



  • As a note, IOTA focuses on asteroid occultations, so computing
    positions daily doesn't always work. Especially for near-Earth
    asteroids, IOTA must iterate considerably more frequently.


  • I also tried contacting Fred Espenak, the creator of
    http://eclipse.gsfc.nasa.gov/SKYCAL/SKYCAL.html, but was unable to
    do so. Jon Giorgini tells me that Fred has retired.


  • I'm still looking, but my current conclusion is that there is no
    good well-known non-iterative way to find planetary conjunctions. As
    the image in my
    https://mathematica.stackexchange.com/questions/92774 shows,
    planetary separations aren't really as well-behaved as I had hoped.


  • I just got a reply from Arnold Barmettler, who runs calsky.com:



I'm using a very time consuming iterative approach to pre-calculate
Bessel Elements for conjunctions. This allows fast online calculation
for any place on earth.
Initial calculations are only done every few years, so CPU time does not
matter. This would change if I'd enter the business to calculate
asteroidal occultations.


re-iterating (pun intended) the same theme.



Miscellaneous:



  • I used planetary system barycenters (the center of mass of a
    planet and its moons) for an entirely different reason. If you ask
    HORIZONS (http://ssd.jpl.nasa.gov/?horizons) for the position of
    Mars and set the date, you'll see this notice:

Available time span for currently selected target body:
1900-Jan-04 to 2500-Jan-04 CT.



However, if you use Mars' barycenter, this becomes:



Available time span for currently selected target body:
BC 9998-Mar-20 to AD 9999-Dec-31 CT.



In other words, NASA computes the position of Mars' planetary system
barycenter for a much longer interval than they compute Mars' actual
position. Since I wanted to compute conjunctions for a long period of
time, I went with the barycenters (DE431 computes barycenters even
beyond 9998 BC and 9999 AD).



I've complained that this is silly, especially for Mars, since the
distance between Mars' center and Mars' planetary system barycenter is
only about 20cm (yes, centimeters, since Phobos and Deimos have very
little mass) per
http://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/planets/aareadme_de430-de431.txt. However,
NASA apparently plans to keep it this way.



  • I ignore light travel time, which introduces a small error. Most
    planetarium programs, like Stellarium, ignore light travel time by
    default, although Stellarium has an option to turn it on.


  • I also ignore refraction, aberration, and similar minor effects.


More details on how I generated these tables (in highly fragmented form):



https://github.com/barrycarter/bcapps/tree/master/ASTRO



(README.conjuncts in the above is a good starting point)



Some of the "cooler" conjunctions I found are at:
http://search.astro.barrycarter.info/table.html. Here's a screenshot:



enter image description here

No comments:

Post a Comment