equationoftime 3.0.0

data/examples/equation_of_time.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python
+"""
+https://bitbucket.org/cmcqueen1975/sundials/src/26a0f54a7c18?at=default
+Calculation of "equation of time".
+
+References:
+    http://en.wikipedia.org/wiki/Equation_of_time
+    http://www.sundials.co.uk/equation.htm
+
+Calculations have been done according to the Wikipedia reference.
+
+Dependencies:
+    - Python 2.x
+    - NumPy
+    - SciPy (only strictly needed for the more accurate calculation)
+    - matplotlib to plot the graph
+"""
+
+import datetime
+from collections import namedtuple
+
+import numpy as np
+import scipy            # only strictly needed for the more accurate calculation in equation_of_time_accurate()
+import scipy.optimize
+
+# Named tuple to hold geographic location
+Location = namedtuple('Location', 'latitude, longitude')
+
+
+# If a location is given, a longitude correction is calculated and included in the graph.
+# If the sundial itself includes the longitude correction, just use the 0 value here.
+LOCATION = Location(0, 0)
+#LOCATION = Location(51.3809, -2.3603)   # Bath, England
+#LOCATION = Location(35.10, 138.86)      # Numazu, Japan
+#LOCATION = Location(-37.81, 144.96)     # Melbourne, Victoria, Australia
+
+
+DAYS_PER_TROPICAL_YEAR = 365.242
+SUN_ECCENTRICITY = 0.01671
+
+# The angle from the vernal equinox to the periapsis in the plane of the ecliptic.
+SUN_ANGLE_OFFSET = 4.9358
+
+# Angle of tilt of earth's axis--about 23.44 degrees
+SUN_OBLIQUITY = 0.40910
+
+
+# Date range for drawing a graph.
+DATE_START = datetime.date(2009, 1, 1)
+DATE_END = datetime.date(2010, 1, 1)
+# Periapsis occurs on a slightly different date each year--varying by a couple
+# of days. 4th of January is about the average.
+DATE_PERIAPSIS = datetime.date(2009, 1, 4)
+
+
+def longitude_offset(location):
+    """Given a location, return the offset due to longitude, in degrees
+    Location's longitude is used. Latitude isn't needed.
+    """
+    longitude = location.longitude
+    longitude_per_hour = (360. / 24)
+    longitude_offset = longitude % longitude_per_hour
+    if longitude_offset > longitude_per_hour / 2:
+        longitude_offset -= longitude_per_hour
+    return longitude_offset
+
+
+def longitude_offset_min(location):
+    minute_per_longitude = 24 * 60 / 360.
+    return longitude_offset(location) * minute_per_longitude
+
+
+def mean_anomaly(day_number_n):
+    """day_number_n is the number of days from periapsis."""
+    return day_number_n * (2 * np.pi / DAYS_PER_TROPICAL_YEAR)
+
+
+@np.vectorize
+def eccentric_anomaly(mean_anomaly_value):
+    local_sun_eccentricity = SUN_ECCENTRICITY
+
+    def eccentric_anomaly_function(eccentric_anomaly_value):
+        return eccentric_anomaly_value - local_sun_eccentricity * np.sin(eccentric_anomaly_value) - mean_anomaly_value
+
+#    eccentric_anomaly_value = scipy.optimize.brentq(eccentric_anomaly_function, 0 - 0.0001, 2 * np.pi + 0.0001)
+    eccentric_anomaly_value = scipy.optimize.fsolve(eccentric_anomaly_function, mean_anomaly_value)
+    return eccentric_anomaly_value
+
+
+def true_anomaly(eccentric_anomaly_value):
+    local_sun_eccentricity = SUN_ECCENTRICITY
+
+    half_eccentric_anomaly = eccentric_anomaly_value / 2
+    a_x = np.cos(half_eccentric_anomaly)
+    a_y = np.sin(half_eccentric_anomaly)
+    a_y *= np.sqrt((1 + local_sun_eccentricity) / (1 - local_sun_eccentricity))
+    return 2 * np.arctan2(a_y, a_x)
+
+
+def right_ascension(sun_angle):
+    """sun_angle is the angle from the vernal equinox to the Sun in the plane of the ecliptic.
+    It is the true_anomaly value plus the SUN_ANGLE_OFFSET."""
+    a_x = np.cos(sun_angle)
+    a_y = np.sin(sun_angle)
+    return np.arctan2(a_y * np.cos(SUN_OBLIQUITY), a_x)
+
+
+def equation_of_time_accurate(day_number_n):
+    """Calculate the equation of time (in min), given a day number.
+    
+    day_number_n is the number of days from periapsis.
+    Returns the difference between solar time and clock time, in minutes.
+    This uses a more accurate calculation.
+    """
+    mean_anomaly_value = mean_anomaly(day_number_n)
+    eccentric_anomaly_value = eccentric_anomaly(mean_anomaly_value)
+    true_anomaly_value = true_anomaly(eccentric_anomaly_value)
+    right_ascension_value = right_ascension(true_anomaly_value + SUN_ANGLE_OFFSET)
+    eot = mean_anomaly_value + SUN_ANGLE_OFFSET - right_ascension_value
+    # Get the angles into the range we want--that is, -pi to +pi
+    eot = (eot + np.pi) % (2 * np.pi) - np.pi
+    return eot * (24 * 60 / 2 / np.pi)
+
+
+def equation_of_time_simple(day_number_n):
+    """Calculate the equation of time (in min), given a day number.
+    
+    day_number_n is the number of days from periapsis.
+    Returns the difference between solar time and clock time, in minutes.
+    This uses a simple, approximate calculation.
+    """
+    mean_anomaly_value = mean_anomaly(day_number_n)
+    return -7.655 * np.sin(mean_anomaly_value) + 9.873 * np.sin(2 * mean_anomaly_value + 3.588)
+
+
+#equation_of_time = equation_of_time_simple
+equation_of_time = equation_of_time_accurate
+
+
+def main():
+    import matplotlib
+    #matplotlib.use('pdf')
+    #matplotlib.use('svg')
+    from matplotlib import pyplot as plt
+
+
+    date_range = np.arange(matplotlib.dates.date2num(DATE_START), matplotlib.dates.date2num(DATE_END), 0.1)
+    day_numbers = date_range - matplotlib.dates.date2num(DATE_PERIAPSIS)
+
+    # Calculate the accurate and simple calculations of equation of time.
+    solar_offset_accurate_min = equation_of_time_accurate(day_numbers) + longitude_offset_min(LOCATION)
+    solar_offset_simple_min = equation_of_time_simple(day_numbers) + longitude_offset_min(LOCATION)
+
+    # Plot the graph, either solar vs clock, or vice-versa.
+    if 1:
+        # Solar time vs clock time
+        plt.plot_date(date_range, solar_offset_accurate_min, '-')
+#        plt.plot_date(date_range, solar_offset_simple_min, '--')
+        plt.ylabel('solar time - clock time (min)')
+    else:
+        # Clock time vs solar time
+        plt.plot_date(date_range, -solar_offset_accurate_min, '-')
+#        plt.plot_date(date_range, -solar_offset_simple_min, '--')
+        plt.ylabel('clock time - solar time (min)')
+
+    # Set month lines
+    ax = plt.subplot(111)
+    ax.xaxis.set_major_locator(matplotlib.dates.MonthLocator())
+    ax.xaxis.set_major_formatter(matplotlib.ticker.NullFormatter())
+    # Set month labels centred in the middle (actually on day 15) of each month.
+    ax.xaxis.set_minor_locator(matplotlib.dates.MonthLocator(bymonthday=15))
+    ax.xaxis.set_minor_formatter(matplotlib.dates.DateFormatter('%b'))
+    for tick in ax.xaxis.get_minor_ticks():
+        tick.tick1line.set_markersize(0)
+        tick.tick2line.set_markersize(0)
+
+    plt.grid(True)
+
+    plt.show()
+#    plt.savefig('equation_of_time.pdf')
+#    plt.savefig('equation_of_time.svg')
+#    plt.savefig('equation_of_time.png')
+
+
+if __name__ == '__main__':
+    main()

data/examples/file_converter.rb

@@ -0,0 +1,31 @@
+# the file this data comes from 'Circular_179.pdf' IAU 2000A Nutation Series
+# the first 678 lines are for lunisolar data
+
+require 'safe_yaml'
+
+# make array elements from each line of the file
+filename = "nutation_table5_3a.txt"
+temp_array = []
+data = File.readlines(filename)
+
+# clean out whitespace and new line breaks 
+data.each {|i| temp_array << i.strip}
+
+# make new muti-dimensional data array
+data = []
+temp_array.each {|i| data << i.split}
+
+# save the array in a yaml file
+File::open( "nutation_table5_3a.yaml", "w" ) do |f|
+  YAML.dump( data, f )
+end
+
+# show the new data file contents as an array.
+data = []
+File.open( "nutation_table5_3a.yaml" )  do |f|
+  YAML.load_documents( f ) do |doc|
+    data = doc
+    p data
+  end
+  p f
+end

data/examples/from_readme.rb

@@ -0,0 +1,10 @@
+# from_readme.rb
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'eot'
+
+eot = Eot.new
+
+puts eot.string_eot()

data/examples/geo_locator.rb

@@ -0,0 +1,12 @@
+# geo_locator.rb
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'eot'
+
+geo = GeoLatLng.new
+geo.addr = "8000 South Michigan Ave., Chicago, IL"
+geo.get_coordinates_from_address
+p geo.lat
+p geo.lng

data/examples/getjd.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'date'
+include Math
+
+def calc_time_julian_centurey(t)
+	# Julian Day Number j(2000) subtracted
+	(t - 2451545.0) / 36525.0
+	# Time in fractional centurey
+end
+
+# Truncate large angles
+def mod_360(x)
+	360.0 * ( x / 360.0 - Integer( x / 360.0))
+end
+
+def calc_mean_long_aries(t)    
+
+    mod_360(280.46061666 + t * 36525.0 * 360.98564736629 + t * (t * 0.000387933 - t * (t / 38710000.0)))
+    
+end
+
+puts "outputs data every 5 seconds"
+loop do
+	time = Time.now.utc
+	theDate = Date.new(time.year, time.month, time.day)
+	# puts time
+	# puts theDate
+	# puts "#{theDate.ajd} = Astronomical Julian Day"
+	# puts "#{theDate.jd - 0.5} = Astronomical Julian Day"
+	# puts "#{theDate.jd} = Julian Day"
+	t = time
+	theDayFraction = (t.usec / (1000000.0 * 3600.0) + t.min / 60.0 + t.hour + t.sec / 3600.0) / 24.0
+	# puts "#{theDayFraction} = Day Fraction time now"
+
+	theTotal = theDate.ajd + theDayFraction
+	# puts "#{theTotal} = Astronomical Julian Day + Day Fraction time now"
+
+	tjc = calc_time_julian_centurey(theTotal)
+	gmst = calc_mean_long_aries(tjc)
+
+	puts "#{gmst.round 3} = (GHA) Mean Hour Angle First Point of Aries (Vernal Equinox)"
+	puts "#{(gmst/15.0).round 3} = Mean Greenwich Siderial Time (GMST)"
+	sleep 5
+end

data/examples/input_suntimes.rb

@@ -0,0 +1,21 @@
+# input_suntimes.rb
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'eot'
+
+eot = Eot.new
+
+@date = Date.today.to_s
+@zone = -5
+puts @date
+eot.date = @date
+geo = GeoLatLng.new
+# note: you will need internet access to get the coordinates next
+geo.addr = "8000 South Michigan Ave., Chicago, IL"
+geo.get_coordinates_from_address
+eot.longitude = geo.lng.to_f
+eot.latitude = geo.lat.to_f
+puts "Sunrise #{eot.sunrise_dt().to_time}"
+puts "Sunset #{eot.sunset_dt().to_time}"

data/examples/julian_day_formula.rb

@@ -0,0 +1,29 @@
+# julian_day_formula.rb
+
+# 3) Dropping the fractional part of all results of all multiplications and divisions, let
+require 'date'
+
+def date_to_ajd date
+  year = date.year
+  month = date.month
+
+  if month <= 2
+    year = year -1
+    month = month +12
+  end
+
+  day = date.day
+  
+  a = (year / 100).floor
+  b  = (a / 4).floor
+  c = 2 - a + b
+  e = (365.25  * (year + 4716)).floor
+  f = (30.6001 * (month +1)).floor
+  c + day + e + f - 1524.5
+end
+
+t = Time.now.utc
+date_string = "#{t.year}-#{t.month}-#{t.day}"
+date = Date.parse(date_string)
+puts t
+puts "Todays date is #{date} and the AJD is #{date_to_ajd date}"

data/examples/julian_day_formula.txt

@@ -0,0 +1,12 @@
+def date_to_jd date
+  
+# 3) Dropping the fractional part of all results of all multiplications and divisions,
+#    let
+  a = year/100
+  b  = a/4
+  c = 2-a+b
+  e = 365.25  * (year + 4716)
+  f = 30.6001 * (m +1)
+  c + d + e + f - 1524.5
+end
+

data/examples/my_time_conversion.rb

@@ -0,0 +1,21 @@
+# my_time_conversion.rb
+
+# This method will convert hours decimal into a Time object and let you see H:M:S format
+def decimal_to_strf(time_in)
+  t = Time.now
+  year = t.year
+  month = t.month
+  day = t.day
+  hours = Integer(time_in)
+  decimal_minutes = (time_in - hours) * 60.0
+  minutes = Integer(decimal_minutes)
+  decimal_seconds = (decimal_minutes - minutes) * 60.0
+  seconds = Integer(decimal_seconds)
+  my_time = Time.new(year, month, day, hours, minutes, seconds, "-05:00")  
+  my_time.strftime("%H:%M:%S")
+end
+
+decimal_hours = 4.64
+puts
+puts "#{decimal_hours} = #{decimal_to_strf(decimal_hours)}"
+puts