SunSet Class Reference

#include <sunset.h>

Public Member Functions
	SunSet ()
	SunSet (double, double, int)
	SunSet (double, double, double)
	~SunSet ()
void	setPosition (double, double, int)
void	setPosition (double, double, double)
void	setTZOffset (int)
void	setTZOffset (double)
double	setCurrentDate (int, int, int)
double	calcNauticalSunrise () const
double	calcNauticalSunset () const
double	calcCivilSunrise () const
double	calcCivilSunset () const
double	calcAstronomicalSunrise () const
double	calcAstronomicalSunset () const
double	calcCustomSunrise (double) const
double	calcCustomSunset (double) const
double	calcSunriseUTC ()
double	calcSunsetUTC ()
double	calcSunrise () const
double	calcSunset () const
int	moonPhase (int) const
int	moonPhase () const

Static Public Attributes
static constexpr double	SUNSET_OFFICIAL = 90.833
static constexpr double	SUNSET_NAUTICAL = 102.0
static constexpr double	SUNSET_CIVIL = 96.0
static constexpr double	SUNSET_ASTONOMICAL = 108.0

Private Member Functions
double	degToRad (double) const
double	radToDeg (double) const
double	calcMeanObliquityOfEcliptic (double) const
double	calcGeomMeanLongSun (double) const
double	calcObliquityCorrection (double) const
double	calcEccentricityEarthOrbit (double) const
double	calcGeomMeanAnomalySun (double) const
double	calcEquationOfTime (double) const
double	calcTimeJulianCent (double) const
double	calcSunTrueLong (double) const
double	calcSunApparentLong (double) const
double	calcSunDeclination (double) const
double	calcHourAngleSunrise (double, double, double) const
double	calcHourAngleSunset (double, double, double) const
double	calcJD (int, int, int) const
double	calcJDFromJulianCent (double) const
double	calcSunEqOfCenter (double) const
double	calcAbsSunrise (double) const
double	calcAbsSunset (double) const

Private Attributes
double	m_latitude
double	m_longitude
double	m_julianDate
double	m_tzOffset
int	m_year
int	m_month
int	m_day

Detailed Description

This class controls all aspects of the operations. The math is done in private functions, and the public API's allow for returning a sunrise/sunset value for the given coordinates and timezone.

The resulting calculations are relative to midnight of the day you set in the setCurrentDate() function. It does not return a time_t value for delta from the current epoch as that would not make sense as the sunrise/sunset can be calculated thousands of years in the past. The library acts on a day timeframe, and doesn't try to assume anything about any other unit of measurement other than the current set day.

You can instantiate this class a few different ways, depending on your needs. It's possible to set your location one time and forget about doing that again if you don't plan to move. Then you only need to change the date and timezone to get correct data. Or, you can simply create an object with no location or time data and then do that later. This is a good mechanism for the setup()/loop() construct.

The most important thing to remember is to make sure the library knows the exact date and timezone for the sunrise/sunset you are trying to calculate. Not doing so means you are going to have very odd results. It's reasonably easy to know when you've forgotten one or the other by looking at the time the sun would rise and noticing that it is X hours earlier or later. That is, if you get a return of 128 minutes (2:08 AM) past midnight when the sun should rise at 308 (6:08 AM), then you probably forgot to set your EST timezone.

The library also has no idea about daylight savings time. If your timezone changes during the year to account for savings time, you must update your timezone accordingly.

Constructor & Destructor Documentation

SunSet() [1/3]

SunSet::SunSet

(

)

Default constructor taking no arguments. It will default all values to zero. It is possible to call calcSunrise() on this type of initialization and it will not fail, but it is unlikely you are at 0,0, TZ=0. This also will not include an initialized date to work from.

               : m_latitude(0.0), m_longitude(0.0), m_julianDate(0.0), m_tzOffset(0.0)
{
}

SunSet() [2/3]

SunSet::SunSet	(	double	lat,
		double	lon,
		int	tz
	)

Parameters

lat	Double Latitude for this object
lon	Double Longitude for this object
tz	Integer based timezone for this object

This will create an object for a location with an integer based timezone value. This constructor is a relic of the original design. It is not deprecated, as this is a valid construction, but the double is preferred for correctness.

                                             : m_latitude(lat), m_longitude(lon), m_julianDate(0.0), m_tzOffset(tz)
{
}

SunSet() [3/3]

SunSet::SunSet	(	double	lat,
		double	lon,
		double	tz
	)

Parameters

lat	Double Latitude for this object
lon	Double Longitude for this object
tz	Double based timezone for this object

This will create an object for a location with a double based timezone value.

                                                : m_latitude(lat), m_longitude(lon), m_julianDate(0.0), m_tzOffset(tz)
{
}

~SunSet()

SunSet::~SunSet

(

)

The destructor has no value and does nothing.

{
}

Member Function Documentation

calcAbsSunrise()

double SunSet::calcAbsSunrise ( double  offset ) const

private

Parameters

offset

Double The specific angle to use when calculating sunrise

Returns

Returns the time in minutes past midnight in UTC for sunrise at your location

This does a bunch of work to get to an accurate angle. Note that it does it 2x, once to get a rough position, and then it doubles back and redoes the calculations to refine the value. The first time through, it will be off by as much as 2 minutes, but the second time through, it will be nearly perfect.

Note that this is the base calculation for all sunrise calls. The others just modify the offset angle to account for the different needs.

{
    double t = calcTimeJulianCent(m_julianDate);
    // *** First pass to approximate sunrise
    double  eqTime = calcEquationOfTime(t);
    double  solarDec = calcSunDeclination(t);
    double  hourAngle = calcHourAngleSunrise(m_latitude, solarDec, offset);
    double  delta = m_longitude + radToDeg(hourAngle);
    double  timeDiff = 4 * delta;   // in minutes of time
    double  timeUTC = 720 - timeDiff - eqTime;  // in minutes
    double  newt = calcTimeJulianCent(calcJDFromJulianCent(t) + timeUTC/1440.0);
 
    eqTime = calcEquationOfTime(newt);
    solarDec = calcSunDeclination(newt);
 
    hourAngle = calcHourAngleSunrise(m_latitude, solarDec, offset);
    delta = m_longitude + radToDeg(hourAngle);
    timeDiff = 4 * delta;
    timeUTC = 720 - timeDiff - eqTime; // in minutes
    return timeUTC; // return time in minutes from midnight
}

References calcEquationOfTime(), calcHourAngleSunrise(), calcJDFromJulianCent(), calcSunDeclination(), calcTimeJulianCent(), m_julianDate, m_latitude, m_longitude, and radToDeg().

Referenced by calcCustomSunrise(), and calcSunriseUTC().

calcAbsSunset()

double SunSet::calcAbsSunset ( double  offset ) const

private

Parameters

offset

Double The specific angle to use when calculating sunset

Returns

Returns the time in minutes past midnight in UTC for sunset at your location

This does a bunch of work to get to an accurate angle. Note that it does it 2x, once to get a rough position, and then it doubles back and redoes the calculations to refine the value. The first time through, it will be off by as much as 2 minutes, but the second time through, it will be nearly perfect.

Note that this is the base calculation for all sunset calls. The others just modify the offset angle to account for the different needs.

{
    double t = calcTimeJulianCent(m_julianDate);
    // *** First pass to approximate sunset
    double  eqTime = calcEquationOfTime(t);
    double  solarDec = calcSunDeclination(t);
    double  hourAngle = calcHourAngleSunset(m_latitude, solarDec, offset);
    double  delta = m_longitude + radToDeg(hourAngle);
    double  timeDiff = 4 * delta;   // in minutes of time
    double  timeUTC = 720 - timeDiff - eqTime;  // in minutes
    double  newt = calcTimeJulianCent(calcJDFromJulianCent(t) + timeUTC/1440.0);
 
    eqTime = calcEquationOfTime(newt);
    solarDec = calcSunDeclination(newt);
 
    hourAngle = calcHourAngleSunset(m_latitude, solarDec, offset);
    delta = m_longitude + radToDeg(hourAngle);
    timeDiff = 4 * delta;
    timeUTC = 720 - timeDiff - eqTime; // in minutes
 
    return timeUTC; // return time in minutes from midnight
}

References calcEquationOfTime(), calcHourAngleSunset(), calcJDFromJulianCent(), calcSunDeclination(), calcTimeJulianCent(), m_julianDate, m_latitude, m_longitude, and radToDeg().

Referenced by calcCustomSunset(), and calcSunsetUTC().

calcAstronomicalSunrise()

double SunSet::calcAstronomicalSunrise

(

)

const

Returns

Returns the Astronomical sunrise in fractional minutes past midnight

This function will return the Astronomical sunrise in local time for your location

{
    return calcCustomSunrise(SUNSET_ASTONOMICAL);
}

References calcCustomSunrise(), and SUNSET_ASTONOMICAL.

calcAstronomicalSunset()

double SunSet::calcAstronomicalSunset

(

)

const

Returns

Returns the Astronomical sunset in fractional minutes past midnight

This function will return the Astronomical sunset in local time for your location

{
    return calcCustomSunset(SUNSET_ASTONOMICAL);
}

References calcCustomSunset(), and SUNSET_ASTONOMICAL.

calcCivilSunrise()

double SunSet::calcCivilSunrise

(

)

const

Returns

Returns the Civil sunrise in fractional minutes past midnight

This function will return the Civil sunrise in local time for your location

{
    return calcCustomSunrise(SUNSET_CIVIL);
}

References calcCustomSunrise(), and SUNSET_CIVIL.

calcCivilSunset()

double SunSet::calcCivilSunset

(

)

const

Returns

Returns the Civil sunset in fractional minutes past midnight

This function will return the Civil sunset in local time for your location

{
    return calcCustomSunset(SUNSET_CIVIL);
}

References calcCustomSunset(), and SUNSET_CIVIL.

calcCustomSunrise()

double SunSet::calcCustomSunrise

(

double

angle

)

const

Parameters

angle

The angle in degrees over the horizon at which to calculate the sunset time

Returns

Returns sunrise at angle degrees in minutes past midnight.

This function will return the sunrise in local time for your location for any angle over the horizon, where < 90 would be above the horizon, and > 90 would be at or below.

{
    return calcAbsSunrise(angle) + (60 * m_tzOffset);
}

References calcAbsSunrise(), and m_tzOffset.

Referenced by calcAstronomicalSunrise(), calcCivilSunrise(), calcNauticalSunrise(), and calcSunrise().

calcCustomSunset()

double SunSet::calcCustomSunset

(

double

angle

)

const

Parameters

angle

The angle in degrees over the horizon at which to calculate the sunset time

Returns

Returns sunset at angle degrees in minutes past midnight.

This function will return the sunset in local time for your location for any angle over the horizon, where < 90 would be above the horizon, and > 90 would be at or below.

{
    return calcAbsSunset(angle) + (60 * m_tzOffset);
}

References calcAbsSunset(), and m_tzOffset.

Referenced by calcAstronomicalSunset(), calcCivilSunset(), calcNauticalSunset(), and calcSunset().

calcEccentricityEarthOrbit()

double SunSet::calcEccentricityEarthOrbit ( double  t ) const

private

{
    double e = 0.016708634 - t * (0.000042037 + 0.0000001267 * t);
    return e;               // unitless
}

Referenced by calcEquationOfTime().

calcEquationOfTime()

double SunSet::calcEquationOfTime ( double  t ) const

private

{
    double epsilon = calcObliquityCorrection(t);
    double l0 = calcGeomMeanLongSun(t);
    double e = calcEccentricityEarthOrbit(t);
    double m = calcGeomMeanAnomalySun(t);
    double y = tan(degToRad(epsilon)/2.0);
 
    y *= y;
 
    double sin2l0 = sin(2.0 * degToRad(l0));
    double sinm   = sin(degToRad(m));
    double cos2l0 = cos(2.0 * degToRad(l0));
    double sin4l0 = sin(4.0 * degToRad(l0));
    double sin2m  = sin(2.0 * degToRad(m));
    double Etime = y * sin2l0 - 2.0 * e * sinm + 4.0 * e * y * sinm * cos2l0 - 0.5 * y * y * sin4l0 - 1.25 * e * e * sin2m;
    return radToDeg(Etime)*4.0; // in minutes of time
}

References calcEccentricityEarthOrbit(), calcGeomMeanAnomalySun(), calcGeomMeanLongSun(), calcObliquityCorrection(), degToRad(), and radToDeg().

Referenced by calcAbsSunrise(), and calcAbsSunset().

calcGeomMeanAnomalySun()

double SunSet::calcGeomMeanAnomalySun ( double  t ) const

private

{
    double M = 357.52911 + t * (35999.05029 - 0.0001537 * t);
    return M;               // in degrees
}

Referenced by calcEquationOfTime(), and calcSunEqOfCenter().

calcGeomMeanLongSun()

double SunSet::calcGeomMeanLongSun ( double  t ) const

private

{
    if (std::isnan(t)) {
        return nan("");
    }
    double L = 280.46646 + t * (36000.76983 + 0.0003032 * t);
 
    return std::fmod(L, 360.0);
}

Referenced by calcEquationOfTime(), and calcSunTrueLong().

calcHourAngleSunrise()

double SunSet::calcHourAngleSunrise ( double  lat, double  solarDec, double  offset  ) const

private

{
    double latRad = degToRad(lat);
    double sdRad  = degToRad(solarDec);
    double HA = (acos(cos(degToRad(offset))/(cos(latRad)*cos(sdRad))-tan(latRad) * tan(sdRad)));
 
    return HA;              // in radians
}

References degToRad().

Referenced by calcAbsSunrise().

calcHourAngleSunset()

double SunSet::calcHourAngleSunset ( double  lat, double  solarDec, double  offset  ) const

private

{
    double latRad = degToRad(lat);
    double sdRad  = degToRad(solarDec);
    double HA = (acos(cos(degToRad(offset))/(cos(latRad)*cos(sdRad))-tan(latRad) * tan(sdRad)));
 
    return -HA;              // in radians
}

References degToRad().

Referenced by calcAbsSunset().

calcJD()

double SunSet::calcJD ( int  y, int  m, int  d  ) const

private

Parameters

y	Integer year as a 4 digit value
m	Integer month, not 0 based
d	Integer day, not 0 based

Returns

Returns the Julian date as a double for the calculations

A well known JD calculator

{
    if (m <= 2) {
        y -= 1;
        m += 12;
    }
    double A = floor(y/100);
    double B = 2.0 - A + floor(A/4);
 
    double JD = floor(365.25*(y + 4716)) + floor(30.6001*(m+1)) + d + B - 1524.5;
    return JD;
}

Referenced by setCurrentDate().

calcJDFromJulianCent()

double SunSet::calcJDFromJulianCent ( double  t ) const

private

{
    double JD = t * 36525.0 + 2451545.0;
    return JD;
}

Referenced by calcAbsSunrise(), and calcAbsSunset().

calcMeanObliquityOfEcliptic()

double SunSet::calcMeanObliquityOfEcliptic ( double  t ) const

private

{
    double seconds = 21.448 - t*(46.8150 + t*(0.00059 - t*(0.001813)));
    double e0 = 23.0 + (26.0 + (seconds/60.0))/60.0;
 
    return e0;              // in degrees
}

Referenced by calcObliquityCorrection().

calcNauticalSunrise()

double SunSet::calcNauticalSunrise

(

)

const

Returns

Returns the Nautical sunrise in fractional minutes past midnight

This function will return the Nautical sunrise in local time for your location

{
    return calcCustomSunrise(SUNSET_NAUTICAL);
}

References calcCustomSunrise(), and SUNSET_NAUTICAL.

calcNauticalSunset()

double SunSet::calcNauticalSunset

(

)

const

Returns

Returns the Nautical sunset in fractional minutes past midnight

This function will return the Nautical sunset in local time for your location

{
    return calcCustomSunset(SUNSET_NAUTICAL);
}

References calcCustomSunset(), and SUNSET_NAUTICAL.

calcObliquityCorrection()

double SunSet::calcObliquityCorrection ( double  t ) const

private

{
    double e0 = calcMeanObliquityOfEcliptic(t);
    double omega = 125.04 - 1934.136 * t;
    double e = e0 + 0.00256 * cos(degToRad(omega));
 
    return e;               // in degrees
}

References calcMeanObliquityOfEcliptic(), and degToRad().

Referenced by calcEquationOfTime(), and calcSunDeclination().

calcSunApparentLong()

double SunSet::calcSunApparentLong ( double  t ) const

private

{
    double o = calcSunTrueLong(t);
 
    double  omega = 125.04 - 1934.136 * t;
    double  lambda = o - 0.00569 - 0.00478 * sin(degToRad(omega));
    return lambda;          // in degrees
}

References calcSunTrueLong(), and degToRad().

Referenced by calcSunDeclination().

calcSunDeclination()

double SunSet::calcSunDeclination ( double  t ) const

private

{
    double e = calcObliquityCorrection(t);
    double lambda = calcSunApparentLong(t);
 
    double sint = sin(degToRad(e)) * sin(degToRad(lambda));
    double theta = radToDeg(asin(sint));
    return theta;           // in degrees
}

References calcObliquityCorrection(), calcSunApparentLong(), degToRad(), and radToDeg().

Referenced by calcAbsSunrise(), and calcAbsSunset().

calcSunEqOfCenter()

double SunSet::calcSunEqOfCenter ( double  t ) const

private

{
    double m = calcGeomMeanAnomalySun(t);
    double mrad = degToRad(m);
    double sinm = sin(mrad);
    double sin2m = sin(mrad+mrad);
    double sin3m = sin(mrad+mrad+mrad);
    double C = sinm * (1.914602 - t * (0.004817 + 0.000014 * t)) + sin2m * (0.019993 - 0.000101 * t) + sin3m * 0.000289;
 
    return C;       // in degrees
}

References calcGeomMeanAnomalySun(), and degToRad().

Referenced by calcSunTrueLong().

calcSunrise()

double SunSet::calcSunrise

(

)

const

Returns

Returns local sunrise in minutes past midnight.

This function will return the Official sunrise in local time for your location

{
    return calcCustomSunrise(SUNSET_OFFICIAL);
}

References calcCustomSunrise(), and SUNSET_OFFICIAL.

Referenced by Calendar::CreateDaylength().

calcSunriseUTC()

double SunSet::calcSunriseUTC

(

)

Returns

Returns the UTC time when sunrise occurs in the location provided

This is a holdover from the original implementation and to me doesn't seem to be very useful, it's just confusing. This function is deprecated but won't be removed unless that becomes necessary.

{
    return calcAbsSunrise(SUNSET_OFFICIAL);
}

References calcAbsSunrise(), and SUNSET_OFFICIAL.

calcSunset()

double SunSet::calcSunset

(

)

const

Returns

Returns local sunset in minutes past midnight.

This function will return the Official sunset in local time for your location

{
    return calcCustomSunset(SUNSET_OFFICIAL);
}

References calcCustomSunset(), and SUNSET_OFFICIAL.

Referenced by Calendar::CreateDaylength().

calcSunsetUTC()

double SunSet::calcSunsetUTC

(

)

Returns

Returns the UTC time when sunset occurs in the location provided

This is a holdover from the original implementation and to me doesn't seem to be very useful, it's just confusing. This function is deprecated but won't be removed unless that becomes necessary.

{
    return calcAbsSunset(SUNSET_OFFICIAL);
}

References calcAbsSunset(), and SUNSET_OFFICIAL.

calcSunTrueLong()

double SunSet::calcSunTrueLong ( double  t ) const

private

{
    double l0 = calcGeomMeanLongSun(t);
    double c = calcSunEqOfCenter(t);
 
    double O = l0 + c;
    return O;               // in degrees
}

References calcGeomMeanLongSun(), and calcSunEqOfCenter().

Referenced by calcSunApparentLong().

calcTimeJulianCent()

double SunSet::calcTimeJulianCent ( double  jd ) const

private

{
    double T = ( jd - 2451545.0)/36525.0;
    return T;
}

Referenced by calcAbsSunrise(), and calcAbsSunset().

degToRad()

double SunSet::degToRad ( double  angleDeg ) const

private

{
    return (M_PI * angleDeg / 180.0);
}

References M_PI.

Referenced by calcEquationOfTime(), calcHourAngleSunrise(), calcHourAngleSunset(), calcObliquityCorrection(), calcSunApparentLong(), calcSunDeclination(), and calcSunEqOfCenter().

moonPhase() [1/2]

int SunSet::moonPhase

(

)

const

Overload to set the moonphase for right now

{
    time_t t = std::time(0);
    return moonPhase(static_cast<int>(t));
}

moonPhase() [2/2]

int SunSet::moonPhase

(

int

fromepoch

)

const

Parameters

fromepoch

time_t seconds from epoch to calculate the moonphase for

This is a simple calculation to tell us roughly what the moon phase is locally. It does not give position. It's roughly accurate, but not great.

The return value is 0 to 29, with 0 and 29 being hidden and 14 being full.

{
    int moonepoch = 614100;
    int phase = (fromepoch - moonepoch) % 2551443;
    int res = static_cast<int>(floor(phase / (24 * 3600))) + 1;
    
    if (res == 30)
        res = 0;
 
    return res;
}

radToDeg()

double SunSet::radToDeg ( double  angleRad ) const

private

{
    return (180.0 * angleRad / M_PI);
}

References M_PI.

Referenced by calcAbsSunrise(), calcAbsSunset(), calcEquationOfTime(), and calcSunDeclination().

setCurrentDate()

double SunSet::setCurrentDate	(	int	y,
		int	m,
		int	d
	)

double SunSet::setCurrentDate(int y, int m, int d)

Parameters

y	Integer year, must be 4 digits
m	Integer month, not zero based (Jan = 1)
d	Integer day of month, not zero based (month starts on day 1)

Returns

Returns the result of the Julian Date conversion if you want to save it

Since these calculations are done based on the Julian Calendar, we must convert our year month day into Julian before we use it. You get the Julian value for free if you want it.

{
    m_year = y;
    m_month = m;
    m_day = d;
    m_julianDate = calcJD(y, m, d);
    return m_julianDate;
}

References calcJD(), m_day, m_julianDate, m_month, and m_year.

Referenced by Calendar::CreateDaylength().

setPosition() [1/2]

void SunSet::setPosition	(	double	lat,
		double	lon,
		double	tz
	)

Parameters

lat	Double Latitude value
lon	Double Longitude value
tz	Double Timezone offset

This will set the location the library uses for it's math. The timezone is included in this as it's not valid to call any of the calc functions until you have set a timezone. It is possible to simply call setPosition one time, with a timezone and not use the setTZOffset() function ever, if you never change timezone values.

{
    m_latitude = lat;
    m_longitude = lon;
    if (tz >= -12 && tz <= 14)
        m_tzOffset = tz;
    else
        m_tzOffset = 0.0;
}

References m_latitude, m_longitude, and m_tzOffset.

setPosition() [2/2]

void SunSet::setPosition	(	double	lat,
		double	lon,
		int	tz
	)

Parameters

lat	Double Latitude value
lon	Double Longitude value
tz	Integer Timezone offset

This will set the location the library uses for it's math. The timezone is included in this as it's not valid to call any of the calc functions until you have set a timezone. It is possible to simply call setPosition one time, with a timezone and not use the setTZOffset() function ever, if you never change timezone values.

This is the old version of the setPosition using an integer timezone, and will not be deprecated. However, it is preferred to use the double version going forward.

{
    m_latitude = lat;
    m_longitude = lon;
    if (tz >= -12 && tz <= 14)
        m_tzOffset = tz;
    else
        m_tzOffset = 0.0;
}

References m_latitude, m_longitude, and m_tzOffset.

Referenced by Calendar::CreateDaylength().

setTZOffset() [1/2]

void SunSet::setTZOffset

(

double

tz

)

Parameters

tz	Double timezone, may be positive or negative

Critical to set your timezone so results are accurate for your time and date. This function is critical to make sure the system works correctly. If you do not set the timezone correctly, the return value will not be correct for your location. Forgetting this will result in return values that may actually be negative in some cases.

{
    if (tz >= -12 && tz <= 14)
        m_tzOffset = tz;
    else
        m_tzOffset = 0.0;
}

References m_tzOffset.

setTZOffset() [2/2]

void SunSet::setTZOffset

(

int

tz

)

Parameters

tz	Integer timezone, may be positive or negative

Critical to set your timezone so results are accurate for your time and date. This function is critical to make sure the system works correctly. If you do not set the timezone correctly, the return value will not be correct for your location. Forgetting this will result in return values that may actually be negative in some cases.

This function is a holdover from the previous design using an integer timezone and will not be deprecated. It is preferred to use the setTZOffset(doubble).

{
    if (tz >= -12 && tz <= 14)
        m_tzOffset = static_cast<double>(tz);
    else
        m_tzOffset = 0.0;
}

References m_tzOffset.

Member Data Documentation

m_day

int SunSet::m_day

private

Referenced by setCurrentDate().

m_julianDate

double SunSet::m_julianDate

private

Referenced by calcAbsSunrise(), calcAbsSunset(), and setCurrentDate().

m_latitude

double SunSet::m_latitude

private

Referenced by calcAbsSunrise(), calcAbsSunset(), and setPosition().

m_longitude

double SunSet::m_longitude

private

Referenced by calcAbsSunrise(), calcAbsSunset(), and setPosition().

m_month

int SunSet::m_month

private

Referenced by setCurrentDate().

m_tzOffset

double SunSet::m_tzOffset

private

Referenced by calcCustomSunrise(), calcCustomSunset(), setPosition(), and setTZOffset().

m_year

int SunSet::m_year

private

Referenced by setCurrentDate().

SUNSET_ASTONOMICAL

constexpr double SunSet::SUNSET_ASTONOMICAL = 108.0

staticconstexpr

Astronomical sun angle for sunset

Referenced by calcAstronomicalSunrise(), and calcAstronomicalSunset().

SUNSET_CIVIL

constexpr double SunSet::SUNSET_CIVIL = 96.0

staticconstexpr

Civil sun angle for sunset

Referenced by calcCivilSunrise(), and calcCivilSunset().

SUNSET_NAUTICAL

constexpr double SunSet::SUNSET_NAUTICAL = 102.0

staticconstexpr

Nautical sun angle for sunset

Referenced by calcNauticalSunrise(), and calcNauticalSunset().

SUNSET_OFFICIAL

constexpr double SunSet::SUNSET_OFFICIAL = 90.833

staticconstexpr

Standard sun angle for sunset

Referenced by calcSunrise(), calcSunriseUTC(), calcSunset(), and calcSunsetUTC().

---

The documentation for this class was generated from the following files:

• /builds/ALMaSS/ALMaSS_MIDox/Landscape/sunset.h
• /builds/ALMaSS/ALMaSS_MIDox/Landscape/sunset.cpp