How to find the first Julian day with the same Earth-Sun constellation

Question

There are quite some sources for astronomical calculation formulas, e.g. Astronomy Answers: Position of the Sun, which is e.g. used by KDE's Night Color plugin to calculate the time of a sunset or sunrise (when the sun's elevation is equal to a given value).

I want to do such a calculation on an Arduino Uno board. The problem is that all those formulas depend on double precision calculations, because they take and return a Julian day with the time being the fraction part. The Arduino Uno only has float precision, so the interesting part, the fraction representing the time, is lost (the Julian day alone takes all the decimal places).

Apparently, it's possible to avoid this problem, e.g. Dr. David Brooks published code to do elevation and azimuth calculations using float precision only in Arduino Uno solar calculations. He splits the Julian day into an integer day part and a float time part.

However, those formulas only work for the current position of the sun at a given date, time and location, not vice versa. I'm interested in calculating the moment in time where the sun has e.g. a given elevation (a defined sunrise and sunset).

I thought that one approach to solve this could be to find the very first Julian day with the very same Earth-Sun constellation, where e.g. the sun had the same elevation at the same time. The day itself is not interesting, as I already know it – I only want to get the time. This way, the Julian day would be <= 365, leaving at least four digits to the time fraction. This would lead to a precision of about 10 s, which would be more than sufficient for my use-case.

So: Is it possible to find the first Julian day with the same Earth-Sun constellation as a given date? Like some modulo operation for a Julian day?

Thanks for all help!

Answer 1

Most formulas accept a Julian Day as input, but internally usually use the number of days (or years, or centuries) since Jan 1, 2000 12:00pm. Take the function below, which accepts JD as input, but the first thing it does is compute n=jd-2451545.0, then uses n for the remainder of the calculations. So it's an easy modification to just have it accept n as the parameter, and not use Julian Days at all in the calling program.

    //Low precision sun position from Astronomical Almanac page C5 (2017 ed).
    //Accuracy 1deg from 1950-2050
    function sunPosition(jd)    {
        const torad=Math.PI/180.0;
        n=jd-2451545.0;
        L=(280.460+0.9856474*n)%360;
        g=((375.528+.9856003*n)%360)*torad;
        if(L<0){L+=360;}
        if(g<0){g+=Math.PI*2.0;}

        lamba=(L+1.915*Math.sin(g)+0.020*Math.sin(2*g))*torad;
        beta=0.0;
        eps=(23.439-0.0000004*n)*torad;
        ra=Math.atan2(Math.cos(eps)*Math.sin(lamba),Math.cos(lamba));
        dec=Math.asin(Math.sin(eps)*Math.sin(lamba));
        if(ra<0){ra+=Math.PI*2;}
        return [ra/torad/15.0,dec/torad];
    }

Here is an example that uses this is function to compute the sun rise and set for a given location.

The here is the Algorithm to solve for a give Altitude or Azimuth

Answer 2

First, a direct answer to your question (as I understand it), and then a different suggestion.

The modulus you are looking for here that brings the Sun and Earth back to the same relative position (in a way that’s relevant for sunrise/sunset calculations rather than positions of stars) is simply a year. More precisely, it is a tropical year. However, that definition doesn’t actually help you that much (at least if you want ~minute precision) because there are year-to-year variations of this of order 5 minutes or so due to the influence of the Moon and planets on Earth’s position.

That said, there is a pretty simple solution, using the code you already linked to. That code calculates the Sun’s elevation for a given date and time. To get the sunrise or sunset time, simply iterate over times in the day until you find the moment where the elevation is zero (though instead you probably want something -0.83 degrees, see explanation here).

Fewer than 12 iterations (0 to 12 hours) would get you the correct hour of sunrise, then <60 iterations each to narrow in on the minute and second. That might seem inefficient (and at some level it is) but it would happen in a tiny fraction of a second; you’re never going to notice the difference between that and some more efficient code you could spend a lot of time writing.