Is there a way in C# to calculate given a latitude and longitude when the sun will set and rise for a given day?
I know this post is old, but in case anyone is still looking...
CoordinateSharp is available as a Nuget package. It s a standalone packge that can handle sun as well as moon times.
Celestial cel = Celestial.CalculateCelestialTimes(85.57682, -70.75678, new DateTime(2017,8,21));
Console.WriteLine(cel.SunRise.Value.ToString());
Note:
It assumes DateTimes are always in UTC.
Lastly, you may need to reference the Celestial objects Sun/Moon .Condition if a date returns null. This occurs when the sun is up/down all day.
EDIT 1/9/2019
The library has changed dramatically since this post. It can now handle local times as well.
This API seems to work for me:
I have tested this nuget package in UWP.
https://www.nuget.org/packages/SolarCalculator/
The documentation is a bit sketchy, and is here:
https://github.com/porrey/Solar-Calculator
You can use this to get the sunrise, given
la = latitude; and lo = longitude; for your area:
SolarTimes solarTimes = new SolarTimes(DateTime.Now, la, lo);
DateTime sr = solarTimes.Sunrise;
DateTime dt = Convert.ToDateTime(sr);
textblockb.Text = dt.ToString("h:mm:ss");
You can install it in Visual Studio using the PM manager
Install-Package SolarCalculator -Version 2.0.2
or by looking up SolarCalculator in the "Manage NuGet Packages" Visual Studio library.
VB.Net version of dotsa s answer, which can also determine time-zones automatically.
Output (checked by watching the sunset this evening):
Main.VB:
Module Main
Sub Main()
http://www.timeanddate.com/sun/usa/seattle
http://www.esrl.noaa.gov/gmd/grad/solcalc/
Vessy, Switzerland
Dim latitude As Double = 46.17062
Dim longitude As Double = 6.161667
Dim dst As Boolean = True
Dim timehere As DateTime = DateTime.Now
Console.WriteLine("It is currently {0:HH:mm:ss} UTC", DateTime.UtcNow)
Console.WriteLine("The time here, at {0}°,{1}° is {2:HH:mm:ss}", latitude, longitude, timehere)
Dim local As TimeZoneInfo = TimeZoneInfo.Local
Dim zone As Integer = local.BaseUtcOffset().TotalHours
If local.SupportsDaylightSavingTime Then
Dim standard As String = local.StandardName
Dim daylight As String = local.DaylightName
dst = local.IsDaylightSavingTime(timehere)
Dim current As String = IIf(dst, daylight, standard)
Console.WriteLine("Daylight-saving time is supported here. Current offset {0:+0} hours, {1}", zone, current)
Else
Console.WriteLine("Daylight-saving time is not supported here")
End If
System.Console.WriteLine("Sunrise today {0}", Sunrises(latitude, longitude))
System.Console.WriteLine("Sunset today {0}", Sunsets(latitude, longitude))
System.Console.ReadLine()
End Sub
End Module
Sun.vb:
Public Module Sun
Get sunrise time at latitude, longitude using local system timezone
Function Sunrises(latitude As Double, longitude As Double) As DateTime
Dim julian As Double = JulianDay(DateTime.Now)
Dim rises As Double = SunRiseUTC(julian, latitude, longitude)
Dim timehere As DateTime = DateTime.Now
Dim local As TimeZoneInfo = TimeZoneInfo.Local
Dim dst As Boolean = local.IsDaylightSavingTime(timehere)
Dim zone As Integer = local.BaseUtcOffset().TotalHours
Dim result As DateTime = getDateTime(rises, zone, timehere, dst)
Return result
End Function
Get sunset time at latitude, longitude using local system timezone
Function Sunsets(latitude As Double, longitude As Double) As DateTime
Dim julian As Double = JulianDay(DateTime.Now)
Dim rises As Double = SunSetUTC(julian, latitude, longitude)
Dim timehere As DateTime = DateTime.Now
Dim local As TimeZoneInfo = TimeZoneInfo.Local
Dim dst As Boolean = local.IsDaylightSavingTime(timehere)
Dim zone As Integer = local.BaseUtcOffset().TotalHours
Dim result As DateTime = getDateTime(rises, zone, timehere, dst)
Return result
End Function
Convert radian angle to degrees
Public Function Degrees(angleRad As Double) As Double
Return (180.0 * angleRad / Math.PI)
End Function
Convert degree angle to radians
Public Function Radians(angleDeg As Double) As Double
Return (Math.PI * angleDeg / 180.0)
End Function
* Name: JulianDay
* Type: Function
* Purpose: Julian day from calendar day
* Arguments:
* year : 4 digit year
* month: January = 1
* day : 1 - 31
* Return value:
* The Julian day corresponding to the date
* Note:
* Number is returned for start of day. Fractional days should be
* added later.
Public Function JulianDay(year As Integer, month As Integer, day As Integer) As Double
If month <= 2 Then
year -= 1
month += 12
End If
Dim A As Double = Math.Floor(year / 100.0)
Dim B As Double = 2 - A + Math.Floor(A / 4)
Dim julian As Double = Math.Floor(365.25 * (year + 4716)) + Math.Floor(30.6001 * (month + 1)) + day + B - 1524.5
Return julian
End Function
Public Function JulianDay([date] As DateTime) As Double
Return JulianDay([date].Year, [date].Month, [date].Day)
End Function
***********************************************************************/
* Name: JulianCenturies
* Type: Function
* Purpose: convert Julian Day to centuries since J2000.0.
* Arguments:
* julian : the Julian Day to convert
* Return value:
* the T value corresponding to the Julian Day
***********************************************************************/
Public Function JulianCenturies(julian As Double) As Double
Dim T As Double = (julian - 2451545.0) / 36525.0
Return T
End Function
***********************************************************************/
* Name: JulianDayFromJulianCentury
* Type: Function
* Purpose: convert centuries since J2000.0 to Julian Day.
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* the Julian Day corresponding to the t value
***********************************************************************/
Public Function JulianDayFromJulianCentury(t As Double) As Double
Dim julian As Double = t * 36525.0 + 2451545.0
Return julian
End Function
***********************************************************************/
* Name: calGeomMeanLongSun
* Type: Function
* Purpose: calculate the Geometric Mean Longitude of the Sun
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* the Geometric Mean Longitude of the Sun in degrees
***********************************************************************/
Public Function GemoetricMeanLongitude(t As Double) As Double
Dim L0 As Double = 280.46646 + t * (36000.76983 + 0.0003032 * t)
While L0 > 360.0
L0 -= 360.0
End While
While L0 < 0.0
L0 += 360.0
End While
Return L0
in degrees
End Function
***********************************************************************/
* Name: calGeomAnomalySun
* Type: Function
* Purpose: calculate the Geometric Mean Anomaly of the Sun
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* the Geometric Mean Anomaly of the Sun in degrees
***********************************************************************/
Public Function GemoetricMeanAnomaly(t As Double) As Double
Dim M As Double = 357.52911 + t * (35999.05029 - 0.0001537 * t)
Return M
in degrees
End Function
***********************************************************************/
* Name: EarthOrbitEccentricity
* Type: Function
* Purpose: calculate the eccentricity of earth s orbit
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* the unitless eccentricity
***********************************************************************/
Public Function EarthOrbitEccentricity(t As Double) As Double
Dim e As Double = 0.016708634 - t * (0.000042037 + 0.0000001267 * t)
Return e
unitless
End Function
***********************************************************************/
* Name: SunCentre
* Type: Function
* Purpose: calculate the equation of center for the sun
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* in degrees
***********************************************************************/
Public Function SunCentre(t As Double) As Double
Dim m As Double = GemoetricMeanAnomaly(t)
Dim mrad As Double = Radians(m)
Dim sinm As Double = Math.Sin(mrad)
Dim sin2m As Double = Math.Sin(mrad + mrad)
Dim sin3m As Double = Math.Sin(mrad + mrad + mrad)
Dim C As Double = sinm * (1.914602 - t * (0.004817 + 0.000014 * t)) + sin2m * (0.019993 - 0.000101 * t) + sin3m * 0.000289
Return C
in degrees
End Function
***********************************************************************/
* Name: SunTrueLongitude
* Type: Function
* Purpose: calculate the true longitude of the sun
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* sun s true longitude in degrees
***********************************************************************/
Public Function SunTrueLongitude(t As Double) As Double
Dim l0 As Double = GemoetricMeanLongitude(t)
Dim c As Double = SunCentre(t)
Dim O As Double = l0 + c
Return O
in degrees
End Function
***********************************************************************/
* Name: SunTrueAnomaly
* Type: Function
* Purpose: calculate the true anamoly of the sun
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* sun s true anamoly in degrees
***********************************************************************/
Public Function SunTrueAnomaly(t As Double) As Double
Dim m As Double = GemoetricMeanAnomaly(t)
Dim c As Double = SunCentre(t)
Dim v As Double = m + c
Return v
in degrees
End Function
***********************************************************************/
* Name: SunDistanceAU
* Type: Function
* Purpose: calculate the distance to the sun in AU
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* sun radius vector in AUs
***********************************************************************/
Public Function SunDistanceAU(t As Double) As Double
Dim v As Double = SunTrueAnomaly(t)
Dim e As Double = EarthOrbitEccentricity(t)
Dim R As Double = (1.000001018 * (1 - e * e)) / (1 + e * Math.Cos(Radians(v)))
Return R
in AUs
End Function
***********************************************************************/
* Name: SunApparentLongitude
* Type: Function
* Purpose: calculate the apparent longitude of the sun
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* sun s apparent longitude in degrees
***********************************************************************/
Public Function SunApparentLongitude(t As Double) As Double
Dim o As Double = SunTrueLongitude(t)
Dim omega As Double = 125.04 - 1934.136 * t
Dim lambda As Double = o - 0.00569 - 0.00478 * Math.Sin(Radians(omega))
Return lambda
in degrees
End Function
***********************************************************************/
* Name: MeanObliquityOfEcliptic
* Type: Function
* Purpose: calculate the mean obliquity of the ecliptic
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* mean obliquity in degrees
***********************************************************************/
Public Function MeanObliquityOfEcliptic(t As Double) As Double
Dim seconds As Double = 21.448 - t * (46.815 + t * (0.00059 - t * (0.001813)))
Dim e0 As Double = 23.0 + (26.0 + (seconds / 60.0)) / 60.0
Return e0
in degrees
End Function
***********************************************************************/
* Name: calcObliquityCorrection
* Type: Function
* Purpose: calculate the corrected obliquity of the ecliptic
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* corrected obliquity in degrees
***********************************************************************/
Public Function calcObliquityCorrection(t As Double) As Double
Dim e0 As Double = MeanObliquityOfEcliptic(t)
Dim omega As Double = 125.04 - 1934.136 * t
Dim e As Double = e0 + 0.00256 * Math.Cos(Radians(omega))
Return e
in degrees
End Function
***********************************************************************/
* Name: SunRightAscension
* Type: Function
* Purpose: calculate the right ascension of the sun
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* sun s right ascension in degrees
***********************************************************************/
Public Function SunRightAscension(t As Double) As Double
Dim e As Double = calcObliquityCorrection(t)
Dim lambda As Double = SunApparentLongitude(t)
Dim tananum As Double = (Math.Cos(Radians(e)) * Math.Sin(Radians(lambda)))
Dim tanadenom As Double = (Math.Cos(Radians(lambda)))
Dim alpha As Double = Degrees(Math.Atan2(tananum, tanadenom))
Return alpha
in degrees
End Function
***********************************************************************/
* Name: SunDeclination
* Type: Function
* Purpose: calculate the declination of the sun
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* sun s declination in degrees
***********************************************************************/
Public Function SunDeclination(t As Double) As Double
Dim e As Double = calcObliquityCorrection(t)
Dim lambda As Double = SunApparentLongitude(t)
Dim sint As Double = Math.Sin(Radians(e)) * Math.Sin(Radians(lambda))
Dim theta As Double = Degrees(Math.Asin(sint))
Return theta
in degrees
End Function
***********************************************************************/
* Name: TrueSolarToMeanSolar
* Type: Function
* Purpose: calculate the difference between true solar time and mean
* solar time
* Arguments:
* t : number of Julian centuries since J2000.0
* Return value:
* equation of time in minutes of time
***********************************************************************/
Public Function TrueSolarToMeanSolar(t As Double) As Double
Dim epsilon As Double = calcObliquityCorrection(t)
Dim l0 As Double = GemoetricMeanLongitude(t)
Dim e As Double = EarthOrbitEccentricity(t)
Dim m As Double = GemoetricMeanAnomaly(t)
Dim y As Double = Math.Tan(Radians(epsilon) / 2.0)
y *= y
Dim sin2l0 As Double = Math.Sin(2.0 * Radians(l0))
Dim sinm As Double = Math.Sin(Radians(m))
Dim cos2l0 As Double = Math.Cos(2.0 * Radians(l0))
Dim sin4l0 As Double = Math.Sin(4.0 * Radians(l0))
Dim sin2m As Double = Math.Sin(2.0 * Radians(m))
Dim Etime As Double = y * sin2l0 - 2.0 * e * sinm + 4.0 * e * y * sinm * cos2l0 - 0.5 * y * y * sin4l0 - 1.25 * e * e * sin2m
Return Degrees(Etime) * 4.0
in minutes of time
End Function
***********************************************************************/
* Name: SunriseHourAngle
* Type: Function
* Purpose: calculate the hour angle of the sun at sunrise for the
* latitude
* Arguments:
* lat : latitude of observer in degrees
* solarDec : declination angle of sun in degrees
* Return value:
* hour angle of sunrise in radians
***********************************************************************/
Public Function SunriseHourAngle(lat As Double, solarDec As Double) As Double
Dim latRad As Double = Radians(lat)
Dim sdRad As Double = Radians(solarDec)
Dim HAarg As Double = (Math.Cos(Radians(90.833)) / (Math.Cos(latRad) * Math.Cos(sdRad)) - Math.Tan(latRad) * Math.Tan(sdRad))
Dim HA As Double = (Math.Acos(Math.Cos(Radians(90.833)) / (Math.Cos(latRad) * Math.Cos(sdRad)) - Math.Tan(latRad) * Math.Tan(sdRad)))
Return HA
in radians
End Function
***********************************************************************/
* Name: SunsetHourAngle
* Type: Function
* Purpose: calculate the hour angle of the sun at sunset for the
* latitude
* Arguments:
* lat : latitude of observer in degrees
* solarDec : declination angle of sun in degrees
* Return value:
* hour angle of sunset in radians
***********************************************************************/
Public Function SunsetHourAngle(lat As Double, solarDec As Double) As Double
Dim latRad As Double = Radians(lat)
Dim sdRad As Double = Radians(solarDec)
Dim HAarg As Double = (Math.Cos(Radians(90.833)) / (Math.Cos(latRad) * Math.Cos(sdRad)) - Math.Tan(latRad) * Math.Tan(sdRad))
Dim HA As Double = (Math.Acos(Math.Cos(Radians(90.833)) / (Math.Cos(latRad) * Math.Cos(sdRad)) - Math.Tan(latRad) * Math.Tan(sdRad)))
Return -HA
in radians
End Function
***********************************************************************/
* Name: SunRiseUTC
* Type: Function
* Purpose: calculate the Universal Coordinated Time (UTC) of sunrise
* for the given day at the given location on earth
* Arguments:
* julian : julian day
* latitude : latitude of observer in degrees
* longitude : longitude of observer in degrees
* Return value:
* time in minutes from zero Z
***********************************************************************/
Public Function SunRiseUTC(julian As Double, latitude As Double, longitude As Double) As Double
Dim t As Double = JulianCenturies(julian)
*** Find the time of solar noon at the location, and use
that declination. This is better than start of the
Julian day
Dim noonmin As Double = SolarNoonUTC(t, longitude)
Dim tnoon As Double = JulianCenturies(julian + noonmin / 1440.0)
*** First pass to approximate sunrise (using solar noon)
Dim eqTime As Double = TrueSolarToMeanSolar(tnoon)
Dim solarDec As Double = SunDeclination(tnoon)
Dim hourAngle As Double = SunriseHourAngle(latitude, solarDec)
Dim delta As Double = longitude - Degrees(hourAngle)
Dim timeDiff As Double = 4 * delta
in minutes of time
Dim timeUTC As Double = 720 + timeDiff - eqTime
in minutes
alert("eqTime = " + eqTime + "
solarDec = " + solarDec + "
timeUTC = " + timeUTC);
*** Second pass includes fractional julianay in gamma calc
Dim newt As Double = JulianCenturies(JulianDayFromJulianCentury(t) + timeUTC / 1440.0)
eqTime = TrueSolarToMeanSolar(newt)
solarDec = SunDeclination(newt)
hourAngle = SunriseHourAngle(latitude, solarDec)
delta = longitude - Degrees(hourAngle)
timeDiff = 4 * delta
timeUTC = 720 + timeDiff - eqTime
in minutes
alert("eqTime = " + eqTime + "
solarDec = " + solarDec + "
timeUTC = " + timeUTC);
Return timeUTC
End Function
***********************************************************************/
* Name: SolarNoonUTC
* Type: Function
* Purpose: calculate the Universal Coordinated Time (UTC) of solar
* noon for the given day at the given location on earth
* Arguments:
* t : number of Julian centuries since J2000.0
* longitude : longitude of observer in degrees
* Return value:
* time in minutes from zero Z
***********************************************************************/
Public Function SolarNoonUTC(t As Double, longitude As Double) As Double
First pass uses approximate solar noon to calculate eqtime
Dim tnoon As Double = JulianCenturies(JulianDayFromJulianCentury(t) + longitude / 360.0)
Dim eqTime As Double = TrueSolarToMeanSolar(tnoon)
Dim solNoonUTC As Double = 720 + (longitude * 4) - eqTime
min
Dim newt As Double = JulianCenturies(JulianDayFromJulianCentury(t) - 0.5 + solNoonUTC / 1440.0)
eqTime = TrueSolarToMeanSolar(newt)
double solarNoonDec = SunDeclination(newt);
solNoonUTC = 720 + (longitude * 4) - eqTime
min
Return solNoonUTC
End Function
***********************************************************************/
* Name: SunSetUTC
* Type: Function
* Purpose: calculate the Universal Coordinated Time (UTC) of sunset
* for the given day at the given location on earth
* Arguments:
* julian : julian day
* latitude : latitude of observer in degrees
* longitude : longitude of observer in degrees
* Return value:
* time in minutes from zero Z
***********************************************************************/
Public Function SunSetUTC(julian As Double, latitude As Double, longitude As Double) As Double
Dim t = JulianCenturies(julian)
Dim eqTime = TrueSolarToMeanSolar(t)
Dim solarDec = SunDeclination(t)
Dim hourAngle = SunriseHourAngle(latitude, solarDec)
hourAngle = -hourAngle
Dim delta = longitude + Degrees(hourAngle)
Dim timeUTC = 720 - (4.0 * delta) - eqTime
in minutes
Return timeUTC
End Function
Public Function SunRiseUTC(julian As Double, latitude As Double, longitude As Double) As Double
Dim t = JulianCenturies(julian)
Dim eqTime = TrueSolarToMeanSolar(t)
Dim solarDec = SunDeclination(t)
Dim hourAngle = SunriseHourAngle(latitude, solarDec)
Dim delta = longitude + Degrees(hourAngle)
Dim timeUTC = 720 - (4.0 * delta) - eqTime
in minutes
Return timeUTC
End Function
Public Function getTimeString(time As Double, timezone As Integer, julian As Double, dst As Boolean) As String
Dim timeLocal = time + (timezone * 60.0)
Dim riseT = JulianCenturies(julian + time / 1440.0)
timeLocal += (If((dst), 60.0, 0.0))
Return getTimeString(timeLocal)
End Function
Public Function getDateTime(time As Double, timezone As Integer, [date] As DateTime, dst As Boolean) As System.Nullable(Of DateTime)
Dim julian As Double = JulianDay([date])
Dim timeLocal = time + (timezone * 60.0)
Dim riseT = JulianCenturies(julian + time / 1440.0)
timeLocal += (If((dst), 60.0, 0.0))
Return getDateTime(timeLocal, [date])
End Function
Private Function getTimeString(minutes As Double) As String
Dim output As String = ""
If (minutes >= 0) AndAlso (minutes < 1440) Then
Dim floatHour = minutes / 60.0
Dim hour = Math.Floor(floatHour)
Dim floatMinute = 60.0 * (floatHour - Math.Floor(floatHour))
Dim minute = Math.Floor(floatMinute)
Dim floatSec = 60.0 * (floatMinute - Math.Floor(floatMinute))
Dim second = Math.Floor(floatSec + 0.5)
If second > 59 Then
second = 0
minute += 1
End If
If (second >= 30) Then
minute += 1
End If
If minute > 59 Then
minute = 0
hour += 1
End If
output = [String].Format("{0:00}:{1:00}", hour, minute)
Else
Return "error"
End If
Return output
End Function
Private Function getDateTime(minutes As Double, [date] As DateTime) As System.Nullable(Of DateTime)
Dim retVal As System.Nullable(Of DateTime) = Nothing
If (minutes >= 0) AndAlso (minutes < 1440) Then
Dim floatHour = minutes / 60.0
Dim hour = Math.Floor(floatHour)
Dim floatMinute = 60.0 * (floatHour - Math.Floor(floatHour))
Dim minute = Math.Floor(floatMinute)
Dim floatSec = 60.0 * (floatMinute - Math.Floor(floatMinute))
Dim second = Math.Floor(floatSec + 0.5)
If second > 59 Then
second = 0
minute += 1
End If
If (second >= 30) Then
minute += 1
End If
If minute > 59 Then
minute = 0
hour += 1
End If
Return New DateTime([date].Year, [date].Month, [date].Day, CInt(hour), CInt(minute), CInt(second))
Else
Return retVal
End If
End Function
End Module
Start with this info:
I m using this to wright a ruby script that is still in the making. I m having trouble understanding the multi-part julian dates.
One thing that is clear is that you should go for exact solar transit time. Then subtract and add the semi_diurnal_arc = acos(cos_omega) which is based upon your latitude and the solar declination. Oh! And be sure to include solar center and earth refraction. It seems this earth is quite the magician.
You need a formula which includes the equation of time to allow for the eccentric orbit of the Earth moon system around the sun. You need to use coordinates with proper datum points such as WGS84 or NAD27 or something like that. You need to use the JULIAN calendar and not the one we use on a daily basis to get5 these times right. It is not an easy thing to guess within a second of time. Id like to have the time at my location where the shadow length is equal to the whatever height. this should happen twice per day when the sun is elevated 60 degrees above the horizon before and after high noon. Also, as far as I understand, you just need to add exactly one day per year to get sidereal time so if you like increase your clock frequency X 366.25/365.25 you might now have a sidereal clock instead of a civil clock ??? "MATH is the LANGUAGE in which someone powerful has written the universe"
If you prefer an external service you could use this nice and free sunrise and sunset times API: http://sunrise-sunset.org/api
I have been using it for several projects and it works very well, data seems to be very accurate. Just do an HTTP GET request to http://api.sunrise-sunset.org/json
Accepted Parameters:
The response includes sunrise and sunset times as well as twilight times.
Yes quit a few.
A few links for patterns.
http://williams.best.vwh.net/sunrise_sunset_example.htm
http://www.codeproject.com/Articles/29306/C-Class-for-Calculating-Sunrise-and-Sunset-Times
https://gist.github.com/cstrahan/767532
http://pointofint.blogspot.com/2014/06/sunrise-and-sunset-in-c.html
http://yaddb.blogspot.com/2013/01/how-to-calculate-sunrise-and-sunset.html
https://forums.asp.net/t/1810934.aspx?Sunrise+and+Sunset+timings+Calculation+
http://www.ip2location.com/tutorials/display-sunrise-sunset-time-using-csharp-and-mysql-database
http://en.pudn.com/downloads270/sourcecode/windows/csharp/detail1235934_en.html
http://regator.com/p/25716249/c_class_for_calculating_sunrise_and_sunset_times
http://forums.xkcd.com/viewtopic.php?t=102253
http://www.redrok.com/solar_position_algorithm.pdf
http://sidstation.loudet.org/sunazimuth-en.xhtml
https://sourceforge.net/directory/os:windows/?q=sunrise/set%20times
https://www.nuget.org/packages/SolarCalculator/
http://www.grasshopper3d.com/forum/topics/solar-calculation-plugin
and this was a project that I did for Planet Source Code long ago but luckily I saved it elsewhere because that site lost data.
https://github.com/DouglasAllen/SunTimes.VSCS.Net
uses this Gist plus
https://gist.github.com/DouglasAllen/c682e4c412a0b9d8f536b014c1766f20
Now for a brief explanation of the technique to do that.
First for any day you need true solar noon or transit for your location.
That takes into account your local longitude. It may be converted to a time just by dividing it by 15.
That is how much time later you are from Zulu zone time or zero longitude.
That starts at 12:00 PM or Noon.
And on your time calculated from the longitude.
Now the hard part. You need a way to calculate the Equation of Time.
That is a time difference caused by Earth tilt and orbit around the Sun.
This will give you an idea... https://en.wikipedia.org/wiki/Equation_of_time
But they have a formula that is much easier.... https://en.wikipedia.org/wiki/Sunrise_equation
This guy has some books that a lot of people go by or buy. :-D https://en.wikipedia.org/wiki/Jean_Meeus
Use your first calculation for your mean solar transit and calculate a JDN... https://en.wikipedia.org/wiki/Julian_day
This gets used by all the angle formulas as a time in Julian century https://en.wikipedia.org/wiki/Julian_year_(astronomy)
https://en.wikipedia.org/wiki/Epoch_(astronomy)
It s basically your JDN minus the epoch such as J2000 or 2451545.0 all divided by 36525.0 to give you the Julian century or t which gets used for most formula that have t as a parameter. Sometimes Julian millennia is used. In that case it s 3652500.0
The trick is to find those angle formulas that help you solve the Equation of Time.
Then you get your true solar transit and subtract the half day or add the half day of sunlight for your location. You ll find those around in the answers and the software.
Once you get something going you can check it against a search for the times or online calculators.
I hope this is enough to get you going. There are libraries all over the place but it s not that hard to make your own. I did but it s in Ruby. It could prove useful....https://github.com/DouglasAllen/gem-equationoftime
good luck!
What is the use of default keyword in C#? Is it introduced in C# 3.0 ?
I m the only developer in my company, and am getting along well as an autodidact, but I know I m missing out on the education one gets from working with and having code reviewed by more senior devs. ...
I m pretty new to the Objective-C world and I have a long history with .net/C# so naturally I m inclined to use my C# wits. Now here s the question: I feel really inclined to create some type of ...
I cannot figure out how to marshal a C++ CBitmap to a C# Bitmap or Image class. My import looks like this: [DllImport(@"test.dll", CharSet = CharSet.Unicode)] public static extern IntPtr ...
I have two EF entities. One has a property called HouseNumber. The other has two properties, one called StartHouseNumber and one called EndHouseNumber. I want to create a many to many association ...
How to user GhostScript DLL to convert PDF to PDF/A. I know I kind of have to call the exported function of gsdll32.dll whose name is gsapi_init_with_args, but how do i pass the right arguments? BTW, ...
Since I cannot order my dictionary, what is the best way of going about taking key value pairs and also maintaing an index?
Maybe it s something I m doing wrong. I m just learning Linq because I m bored. And so far so good. I made a little program and it basically just outputs all matches (foreach) into a label control. ...