How to calculate eclipses on a planet in a binary star system

Question

How could one calculate eclipses on a planet (in a game) with one moon and orbiting two stars?

More Info:

Every so often--roughly every 5 years--the moon (this planet has a single moon) is in a position to cause a partial eclipse on the planet (i.e. blocking only one star). If you’re lucky, you may even witness a total eclipse where both stars are blocked. A full Synodic period for this planet is almost 11 years. I have yet to find a method to find out when such anomalies will occur next.

Eclipses occur roughly every 5 years. I do not know the month or the day or if there will be a total eclipse where both stars are blocked in a given year.

So far, I used this page to find the Saros period. Unfortunately, my calculations were off (can this page even be used for a double star system?). These sets of equations are also geared towards a moon that is on the same orbital plane as our moon which is not the case at all with this fictional moon and system.

A picture is worth 1,000 words so I will provide one here rather than further describe the star orbit:

1: Is there a way to calculate when eclipses will happen in this star system?

2: Is there a way to calculate if it will be a total eclipse (given the positions of the stars, center of mass etc.)?

---

---

The game is quite advanced; orbits are simulated and so is gravity. From what I can tell this is “as close as it gets” for a video game. Information regarding the orbits, masses, gravity, velocity and everything in between can be found within the game and provided here.

Nonetheless, I want to know how to do this just for fun even if it can’t be predicted within the game.

Here is the wiki pages for the game:

*https://en.wikipedia.org/wiki/SpaceEngine (wiki page)

https://se-database.fandom.com/wiki/Space_Engine_Database (planetary database)

http://spaceengine.org/ (main website)*

As a side note: I am referring to a solar eclipse that can be seen on the surface of this planet where one or both stars are blocked by the moon that orbits

EDIT:

The planet orbits both stars. As do the other planets.

There is a rather large Neptune like planet nearby which could be affecting the planet. Below are some more images/gif animations to show the system in more detail. The moon also appears to be affecting the orbit of the planet! Because of this, the planet has a slight wobble which is also shown below.

Planet Orbit (Planet orbit is highlighted in pink; the nearby Neptune planet is the next orbit):

Planet Wobble (most likely because of moon orbiting close by, its mass is is about half of the moon's but it is much closer at a distance of 83,799 km or 52,070 mi):

Moon Orbit Showing Eclipse (as mentioned before, every 5 or 6 years the moon goes through a cycle of eclipses blocking each star roughly 5 times depending on their positions):

Planet Data (gathered from game):

Inclination: -1 degree

Orbital Period: 10.802 years

Pericenter/Apocenter: 8.7571 AU/10.0095 AU

Mass: 0.16163 M⊕

Moon Data:

Inclination: 0 degrees

Orbital Period: 7.205

Diameter: 2,556 km or 1,588 mi

Mass: 0.55884 Lunar Mass or 0.00687 M⊕

Distance to Planet: 83,799 km or 52,070 mi

Neptune Planet Data:

Inclination: 0 degrees

Orbital Period: 7.205

Mass: 13.569 M⊕

Diameter: 361,859 km or 224,849 mi

Orbital Period: 15.481 years

Pericenter/Apocenter:11.0257 AU/12.8287 AU

Distance to Planet: 15.37 AU

Hill/Sphere of Influence: 0.14 AU/0.10 AU

There are many planets in it but the closest is the Neptune like planet.

We can also say that the game uses Keplerian orbits for simplicity; although this page (http://spaceengine.org/news/blog180817/) has a quote that confuses me slightly:

Previously, SpaceEngine used Kepler orbits – they are a good approximation of the motion of a planet around the Sun (or of a moon around a planet) without any perturbations. But the real Solar system is not so simple, we have multiple planets and moons which pull each other with their gravity.

I think this can be ignored for simplicity sake because it is more talking about our solar system not this procedurally generated one. Additionally, I am not sure that the engine is advanced enough to simulate exact orbits.

Answer 1

There isn't a general closed form solution for the n-body problem for n>2, so a general solution to this problem can't be given without additional constraints on the problem. Does the planet orbit both stars in a close binary system from far away? Or does the planet orbit only one of the stars in a wide binary system? Can we consider the orbits to be Keplerian for a good enough approximation?

If we have an engine that gives us the positions of the bodies at any time, we can perform a numerical solution as follows. Given the positions $\vec{p}_s$ of a star, an observer $\vec{p}_p$, and a moon $\vec{p}_m$ at any particular time $t$,

the apparent angular radius of the moon in the sky as observed from the planet is $$\theta_m = \sin^{-1}\biggl(\dfrac{r_m}{|\vec{p}_m-\vec{p}_p|}\biggr)$$ where $r_m$ is the radius of the moon. Similarly, the apparent angular radius of a star as observed from the planet is $$\theta_s = \sin^{-1}\biggl(\dfrac{r_s}{|\vec{p}_s-\vec{p}_p|}\biggr)$$ where $r_s$ is the radius of the star.

It should be clear that the only way a total stellar eclipse is possible is if $\theta_m \geq \theta_s$.

To obtain the angular separation $\alpha$ between the center of the star and the center of the moon in the sky as observed from the planet, we start with the definition of the vector dot product: $A \cdot B = |A||B|\cos(\alpha)$, and solve for $\alpha$ to get $$\alpha = \cos^{-1}\biggl(\frac{A \cdot B}{|A||B|}\biggr) $$

Here, $A = \vec{p}_m-\vec{p}_p$, and $B = \vec{p}_s-\vec{p}_p$ are vectors to the star and moon from the observer rather than the reference system origin.

If $\theta_m+\theta_s \geq \alpha$, then an eclipse is occurring at time $t$. In addition, if $\theta_m \geq \theta_s+\alpha$ a total eclipse is occurring.

Notes:

1. This is a solution for only a single star for simplicity. For additional stars the same above equations can be used.

2. How do you choose the right value of $t$ to correspond to the time of eclipses when you don't know when the eclipse will occur? Try many values of $t$ in a loop with small increments. Where values of $\alpha$ are small, try even smaller increments of $t$ over smaller intervals.

Answer 2

I agree with @ConnorGarcia's answer that numerical solutions are the only practical way to go here.

Further evidence can be found in the following paragraph from the site's webpage which was noted in the question.

In fact, noticing this bit and pointing it out was a great call; it's really the gateway to understanding what's going on here!

Over the past month I have worked on planet ephemerides¹. They are data tables and pieces of code, which provide the precise positions and velocities of the Solar system’s planets and moons at a given moment in time. Previously, SpaceEngine used Kepler orbits – they are a good approximation of the motion of a planet around the Sun (or of a moon around a planet) without any perturbations. But the real Solar system is not so simple, we have multiple planets and moons which pull each other with their gravity. This perturbs their orbits, making the Keplerian solution inaccurate. The most significant perturbations are applied to the moons, as you can see on the video below – their orbits precess and wobble.

I'm pretty sure this means that the author got a numerical integrator (a library function or bit of standard code), put some starting positions, velocities and directions (state vectors) into it and let it run for a few hundred "years" or "centuries".

What does "data tables and pieces of code" mean?

They produced an ephemeris (one or more) which is a data table of positions (and sometimes other parameters) at a large number of points in time. They also provided interpolators or "pieces of code" that you would give a series of time points to, and it would look up the closest time values in the ephemeris and interpolate between the fixed points of the table.

Many astronomical ephemerides contain the positions and interpolation coefficients to make the interpolation more accurate. NASA Jet Propulsion Laboratory's Development Ephemerides are a wonderful and well-known example. It's not important here, but they use a custom-defined implementation of Chebychev polynomials that even out the residual interpolation error along the trajectory.

In order to obtain eclipses, one would simply apply some kind of "potential eclipse detector" or generalized event detector to the problem.

You would scan the ephemeris table and look for regions where the Sun-planet-moon angle is small. This is shown in @ConnorGarcia's answer.

But.. HOW???

If you can't get the ephemeris that's used inside the game/model, then try to make one for yourself.

Run the game for a century or millennium and output x, y, z positions for the stars, planet and moon, or if that's not possible, output the star-planet-moon angle for each star.

Then calculate those vectors and look for local minima. Easiest way is to caclulate the changes in angle from one time point to the next. You've found a minimum or at least inflection point if you multiply two adjacent changes together and the product is either zero or negative.

In Python, that would be:

d_theta = theta[1:] - theta[:-1]
dd_theta = d_theta[1:] * d_theta[:-1]
inflections_and_minima = dd__theta <= 0

It's tempting to use < instead of <= but there's an extremely tiny chance that two points could straddle a minimum leading to an accidental 0.

---

¹How to pronounce “Ephemerides”? hint: it's not eee-FEM-er-IDES.