Calculating the regular synodic period of two orbiting bodies is pretty straight forward, but what if I wanted to know when they would meet in a specific position? For example if they share a periapse. (By "same position" I mean that the two orbiting objects and the central body are on the same line)
I know this only applies if you can express one of the bodies period as a fraction of the other, so a 1 and a sqrt(2) orbit would never sync.
But what if I decided an acceptable margin? (like 10 degrees)

Currently I am brute forcing this.

My question is: Is it a way to calculate the next time two bodies would meet each other at the same location, given their orbital period and an acceptable error?

The objects does not have a noticeable effect on each other, nor on the central body. Restrict to circular or co-planar if necessary.

  • 1
    $\begingroup$ Can you elaborate on "the same position"? Do you mean the same angular position (true anomaly plus argument of periapsis?). $\endgroup$ – Brian Lynch Dec 13 '15 at 0:11
  • 1
    $\begingroup$ @Brian Lynch Thank you for the comment. Yes, clarified it in the question. $\endgroup$ – SE - stop firing the good guys Dec 13 '15 at 0:30
  • 1
    $\begingroup$ Are the orbits circular? Co-planar? Assumed to both be very small compared to the central body with negligible effect on each other so as to have a simple solution? $\endgroup$ – Mark Adler Dec 13 '15 at 1:07
  • $\begingroup$ @Mark Adler, Yes, their effect on each other and the central body is negligible. As for circular and co-planar, they do not have to be, but a solution restricted to one ore both of them would be helpful too. Feel free to give a partial answer. My current work around is using time increments. $\endgroup$ – SE - stop firing the good guys Dec 13 '15 at 1:18
  • $\begingroup$ Somewhat related: physics.stackexchange.com/questions/197481/… $\endgroup$ – user7073 Jan 31 '16 at 16:19

This is what eventually solved my problem. This JavaScript function takes the parameters: radiusRatio, the outermost objects radius divided by the innermosts. innerAnomaly, the innermost objects true anomaly from the reference direction, same for outerAnomaly, errorMargin is the maximal angle between either of the two radius vectors or the reference direction, and limit is how many of the innermost objects orbits to simulate for.

Note that the angle measure used for innerAnomaly, outerAnomaly and errorMargin is in fractions of an orbit, not degrees nor radians.

sameLine = function (radiusRatio,innerAnomaly,outerAnomaly,errorMargin,limit){
    results = [];
    newMargin = errorMargin;
    periodRatio = Math.pow(radiusRatio,3/2);
    for (i = 1; i < limit; i++){
        anomaly = (outerAnomaly + (i - innerAnomaly)/periodRatio) % 1;
        if (anomaly > 1 - anomaly){
            anomaly = 1 - anomaly;
        if (anomaly <= newMargin){
            results.push([i - innerAnomaly,anomaly]);
            newMargin = anomaly;
    return results;

It outputs the an array containing sub arrays with the encounter data in the format of 1 numbers of orbits the innermost object has performed, and 2 what the error margin was. The next entry is the next time the error is smaller than that.

It is of course restricted to coplanar, circular orbits, and the mass of the two orbiting objects is negligible.

I have a more detailed explanation for a related problem at https://physics.stackexchange.com/a/232918/102747

| improve this answer | |

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.