How to calculate conjunctions of 2 planets

Question

So, the recent conjunction of Jupiter and Venus seems to have spawned lots of excitement over this "rare" event. But what I can't figure out, is exactly how rare it is. And I've seen such conflicting claims and calculations that I figured I'd better calculate it myself. The only problem is I'm no astronomer. So, does anyone know of a program that can calculate all the conjunctions between a date range that are within a degree of each other? Or does smart person know how to calculate it manually? :) I have a program called Stellerium which I've been using to view the various conjunctions that people have mentioned. I don't know if I can use it in the way I need it though. Any help? :) Thanks

Answer 1

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://12d4dc067e0d836f1541e50125c24a03.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...

• As https://math.stackexchange.com/questions/95250/ notes, people have been interested in finding planetary conjunctions for at least 2000 years, probably longer. The first such known tool is the https://en.wikipedia.org/wiki/Antikythera_mechanism. The "Operation" section of the wikipedia page suggests this device was hand-cranked, and thus iterative.

• SPICE (https://en.wikipedia.org/wiki/Spacecraft_Planet_Instrument_C-matrix_Events) is one of the oldest digital computer attempts to compute planetary positions, and it includes a routine to compute conjunctions:

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.

• Akkana Peck ([email protected]), creator of a well known script to find conjunctions (https://github.com/akkana/scripts/blob/master/conjunctions.py) tells me:

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 ([email protected]) 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.

• I contacted IOTA (http://occultations.org/) and they confirmed they use an iterative method as well:

[...] 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:

Answer 2

The PyEphem library allows you to create Python scripts that could calculate any conjunction you want (and many other things besides that).

http://rhodesmill.org/pyephem/

Here's a script that already does that:

http://shallowsky.com/blog/science/astro/predicting-conjunctions.html

Here's the result of running that script now:

http://pastebin.com/ehjxV66m

Notable event: extremely close conjunction between Jupiter and Venus in 2016:

Conjunction of Venus and Jupiter lasts from 2016/8/25 to 2016/8/31.
  Venus and Jupiter are closest on 2016/8/28 (0.1 deg).

Answer 3

I worked out this equation to determine the cycle length between conjunctions of two planets:

$$t = \frac{a \cdot b}{b-a}$$

where:

t = length of conjunction cycle (ie time between two conjunctions), in Earth days

a = year length for lower-orbit planet, in Earth days

b = year length for higher-orbit planet, in Earth days

Answer 4

You can calculate conjunction year with the formula $$ 1/(1/F1 - 1/P1). F1 $$

$P1$ is the revolution time of a celestial body like a planet, asteroid etc. By substituting Jupiter and Saturn data we find it's 19.8 years