RubySunrise 0.1.0

data/lib/sunrise.rb

@@ -0,0 +1,190 @@
+require 'bigdecimal'
+require 'date'
+
+class SolarEventCalculator
+
+  @date
+  @latitude
+  @longitude
+
+  def initialize(date, latitude, longitude)
+    @date = date
+    @latitude = latitude
+    @longitude = longitude
+  end
+
+  def compute_longitude_hour
+    lngHour = @longitude / BigDecimal.new("15")
+    lngHour.round(4)
+  end
+
+  def compute_rise_longitude_hour
+    longHour = @date.yday + ((BigDecimal.new("6") - compute_longitude_hour) / BigDecimal.new("24"))
+    longHour.round(4)
+  end
+
+  def compute_set_longitude_hour
+    longHour = @date.yday + ((BigDecimal.new("18") - compute_longitude_hour) / BigDecimal.new("24"))
+    longHour.round(4)
+  end
+
+  def compute_sun_mean_anomaly(longHour)
+    constant = BigDecimal.new("0.9856")
+    ((longHour * constant) - BigDecimal.new("3.289")).round(4)
+  end
+
+  def compute_sun_true_longitude(meanAnomaly)
+    mAsRads = degrees_as_rads(meanAnomaly)
+    sinM = BigDecimal.new(Math.sin(mAsRads.to_f).to_s)
+    sinTwoM = BigDecimal.new(Math.sin((2 * mAsRads).to_f).to_s)
+    firstParens = BigDecimal.new("1.916") * sinM
+    secondParens = BigDecimal.new("0.020") * sinTwoM
+    trueLong = meanAnomaly + firstParens + secondParens + BigDecimal.new("282.634")
+    trueLong = put_in_range(trueLong, 0, 360, 360)
+    trueLong.round(4)
+  end
+
+  def compute_right_ascension(sunTrueLong)
+    tanL = BigDecimal.new(Math.tan(degrees_as_rads(sunTrueLong).to_f).to_s)
+    ra = rads_as_degrees(BigDecimal.new(Math.atan(BigDecimal.new("0.91764") * tanL).to_s))
+
+    ra = put_in_range(ra, 0, 360, 360)
+    ra.round(4)
+  end
+
+  def put_ra_in_correct_quadrant(sunTrueLong)
+    lQuadrant = BigDecimal.new("90") * (sunTrueLong / BigDecimal.new("90")).floor
+    raQuadrant = BigDecimal.new("90") * (compute_right_ascension(sunTrueLong) / BigDecimal.new("90")).floor
+
+    ra = compute_right_ascension(sunTrueLong) + (lQuadrant - raQuadrant)
+    ra = ra / BigDecimal.new("15")
+    ra.round(4)
+  end
+
+  def compute_sin_sun_declination(sunTrueLong)
+    sinL = BigDecimal.new(Math.sin(degrees_as_rads(sunTrueLong).to_f).to_s)
+    sinDec = sinL * BigDecimal.new("0.39782")
+    sinDec.round(4)
+  end
+
+  def compute_cosine_sun_declination(sinSunDeclination)
+    cosDec = BigDecimal.new(Math.cos(Math.asin(sinSunDeclination)).to_s)
+    cosDec.round(4)
+  end
+
+  def compute_cosine_sun_local_hour(sunTrueLong, zenith)
+    cosZenith = BigDecimal.new(Math.cos(degrees_as_rads(BigDecimal.new(zenith.to_s))).to_s)
+    sinLatitude = BigDecimal.new(Math.sin(degrees_as_rads(@latitude)).to_s)
+    cosLatitude = BigDecimal.new(Math.cos(degrees_as_rads(@latitude)).to_s)
+
+    sinSunDeclination = compute_sin_sun_declination(sunTrueLong)
+    top = cosZenith - (sinSunDeclination * sinLatitude)
+    bottom = compute_cosine_sun_declination(sinSunDeclination) * cosLatitude
+
+    cosLocalHour = top / bottom
+    cosLocalHour.round(4)
+  end
+
+  def compute_sunrise_local_hour_angle(cosSunLocalHour)
+    acosH = BigDecimal.new(Math.acos(cosSunLocalHour).to_s)
+    localHourAngle = BigDecimal.new("360") - rads_as_degrees(acosH)
+    localHourAngle = localHourAngle / BigDecimal.new("15")
+    localHourAngle.round(4)
+  end
+
+  def compute_sunset_local_hour_angle(cosSunLocalHour)
+    acosH = BigDecimal.new(Math.acos(cosSunLocalHour).to_s)
+    acosH = rads_as_degrees(acosH)
+    localHourAngle = acosH / BigDecimal.new("15")
+    localHourAngle.round(4)
+  end
+
+  def compute_local_mean_time(sunTrueLong, longHour, t,  sunLocalHour)
+    h = sunLocalHour
+    ra = put_ra_in_correct_quadrant(sunTrueLong)
+
+    parens = BigDecimal.new("0.06571") * t
+    time = h + ra - parens - BigDecimal.new("6.622")
+
+    utcTime = time - longHour
+    utcTime = put_in_range(utcTime, 0, 24, 24)
+    utcTime.round(4)
+  end
+
+  def compute_utc_sunrise(zenith)
+    longHour = compute_longitude_hour
+    riseLongHour = compute_rise_longitude_hour
+
+    meanAnomaly = compute_sun_mean_anomaly(riseLongHour)
+    sunTrueLong = compute_sun_true_longitude(meanAnomaly)
+    cosineSunLocalHour = compute_cosine_sun_local_hour(sunTrueLong, zenith)
+
+    if(cosineSunLocalHour > BigDecimal.new("1") || cosineSunLocalHour < BigDecimal.new("-1"))
+      return nil
+    end
+
+    sunLocalHour = compute_sunrise_local_hour_angle(cosineSunLocalHour)
+    localMeanTime = compute_local_mean_time(sunTrueLong, longHour, riseLongHour, sunLocalHour)
+
+    timeParts = localMeanTime.to_s('F').split('.')
+    mins = BigDecimal.new("." + timeParts[1]) * BigDecimal.new("60")
+    mins = mins.truncate()
+    mins = pad_minutes(mins.to_i)
+    hours = timeParts[0]
+
+    Time.gm(@date.year, @date.mon, @date.mday, hours, pad_minutes(mins.to_i))
+  end
+
+  def compute_utc_sunset(zenith)
+    longHour = compute_longitude_hour
+    setLongHour = compute_set_longitude_hour
+
+    meanAnomaly = compute_sun_mean_anomaly(setLongHour)
+    sunTrueLong = compute_sun_true_longitude(meanAnomaly)
+    cosineSunLocalHour = compute_cosine_sun_local_hour(sunTrueLong, zenith)
+
+    if(cosineSunLocalHour > BigDecimal.new("1") || cosineSunLocalHour < BigDecimal.new("-1"))
+      return nil
+    end
+
+    sunLocalHour = compute_sunset_local_hour_angle(cosineSunLocalHour)
+    localMeanTime = compute_local_mean_time(sunTrueLong, longHour, setLongHour, sunLocalHour)
+
+    timeParts = localMeanTime.to_s('F').split('.')
+    mins = BigDecimal.new("." + timeParts[1]) * BigDecimal.new("60")
+    mins = mins.truncate()
+    hours = timeParts[0]
+
+    Time.gm(@date.year, @date.mon, @date.mday, hours, pad_minutes(mins.to_i))
+  end
+
+  def pad_minutes(minutes)
+    if(minutes < 10)
+      "0" + minutes.to_s
+    else
+      minutes
+    end
+  end
+
+  def put_in_range(number, lower, upper, adjuster)
+    if number > upper then
+      number -= adjuster
+    elsif number < lower then
+      number += adjuster
+    else
+      number
+    end
+  end
+
+  def degrees_as_rads(degrees)
+    pi = BigDecimal(Math::PI.to_s)
+    radian = pi / BigDecimal.new("180")
+    degrees * radian
+  end
+
+  def rads_as_degrees(radians)
+    pi = BigDecimal(Math::PI.to_s)
+    degree = BigDecimal.new("180") / pi
+    radians * degree
+  end
+end

data/rubysunrise.gemspec

@@ -0,0 +1,12 @@
+spec = Gem::Specification.new do | s |
+  s.name = "RubySunrise"
+  s.version = "0.1.0"
+  s.author = "Mike Reedell / LuckyCatLabs"
+  s.email = "mike@luckycatlabs.com"
+  s.homepage = "http://www.luckycatlabs.com"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Calculate the sunrise/sunset given lat/long coordinates and the date.  Computes civil, official, nautical, and astronomical sunrise/sunset."
+  s.files = ["rubysunrise.gemspec"] + Dir.glob("lib/**/*")
+  s.test_files = Dir.glob("{test}/**/*test.rb")
+  s.has_rdoc = false
+end

data/test/sunrisetest.rb

@@ -0,0 +1,89 @@
+require 'sunrise'
+
+describe SolarEventCalculator, "test the math for home" do
+
+  before do
+    @date = Date.parse('2008-11-01') #01 November 2008
+    @calc = SolarEventCalculator.new(@date, BigDecimal.new("39.9537"), BigDecimal.new("-75.7850"))
+  end
+
+  it "returns correct longitude hour" do
+    @calc.compute_longitude_hour.should eql(BigDecimal.new("-5.0523"))
+  end
+
+  it "returns correct longitude hour" do
+    @calc.compute_rise_longitude_hour.should eql(BigDecimal.new("306.4605"))
+  end
+
+  it "returns correct sunrise mean anomaly" do
+    @calc.compute_sun_mean_anomaly(BigDecimal.new("306.4605")).should eql(BigDecimal.new("298.7585"))
+  end
+
+  it "returns correct sunrise's sun true longitude" do
+    @calc.compute_sun_true_longitude(BigDecimal.new("298.7585")).should eql(BigDecimal.new("219.6960"))
+  end
+
+  it "returns correct sunrise's right ascension" do
+    @calc.compute_right_ascension(BigDecimal.new("219.6960")).should eql(BigDecimal.new("37.2977"))
+  end
+
+  it "returns correct sunrise's right ascension quadrant" do
+    @calc.put_ra_in_correct_quadrant(BigDecimal.new("219.6960")).should eql(BigDecimal.new("14.4865"))
+  end
+
+  it "returns correct sunrise sin sun declination" do
+    @calc.compute_sin_sun_declination(BigDecimal.new("219.6960")).should eql(BigDecimal.new("-0.2541"))
+  end
+
+  it "returns correct sunrise cosine sun declination" do
+    @calc.compute_cosine_sun_declination(BigDecimal.new("-0.2541")).should eql(BigDecimal.new("0.9672"))
+  end
+
+  it "returns correct sunrise cosine sun local hour" do
+    @calc.compute_cosine_sun_local_hour(BigDecimal.new("219.6960"), 96).should eql(BigDecimal.new("0.0791"))
+  end
+
+  it "returns correct sunrise local hour angle" do
+    @calc.compute_sunrise_local_hour_angle(BigDecimal.new("0.0791")).should eql(BigDecimal.new("18.3025"))
+  end
+
+  it "returns correct sunrise local mean time" do
+    trueLong = BigDecimal.new("219.6960")
+    longHour = BigDecimal.new("-5.0523")
+    localHour = BigDecimal.new("18.3025")
+    t = BigDecimal.new("306.4605")
+    @calc.compute_local_mean_time(trueLong, longHour, t, localHour).should eql(BigDecimal.new("11.0818"))
+  end
+
+  it "returns correct civil sunrise time" do
+    @calc.compute_utc_sunrise(96).should eql(Time.gm(@date.year, @date.mon, @date.mday, 11, 4))
+  end
+
+  it "returns correct official sunrise time" do
+    @calc.compute_utc_sunrise(90.8333).should eql(Time.gm(@date.year, @date.mon, @date.mday, 11, 33))
+  end
+
+  it "returns correct nautical sunrise time" do
+    @calc.compute_utc_sunrise(102).should eql(Time.gm(@date.year, @date.mon, @date.mday, 10, 32))
+  end
+
+  it "returns correct astronomical sunrise time" do
+    @calc.compute_utc_sunrise(108).should eql(Time.gm(@date.year, @date.mon, @date.mday, 10, 1))
+  end
+end
+
+describe SolarEventCalculator, "test the math for areas where there could be no rise/set" do
+
+  it "returns correct time" do
+    date = Date.parse('2008-04-25') #25 April 2008
+    calc = SolarEventCalculator.new(date, BigDecimal.new("64.8378"), BigDecimal.new("-147.7164"))
+    calc.compute_utc_sunrise(108).should eql(nil)
+  end
+
+  it "returns correct time" do
+    date = Date.parse('2008-04-25') #25 April 2008
+    calc = SolarEventCalculator.new(date, BigDecimal.new("64.8378"), BigDecimal.new("-147.7164"))
+    calc.compute_utc_sunrise(102).should eql(nil)
+  end
+end
+

data/test/sunsettest.rb

@@ -0,0 +1,89 @@
+require 'sunrise'
+
+describe SolarEventCalculator, "Test the sunset algorithm" do
+
+  before do
+    @date = Date.parse('2008-11-01') #01 November 2008
+    @calc = SolarEventCalculator.new(@date, BigDecimal.new("39.9537"), BigDecimal.new("-75.7850"))
+  end
+
+  it "returns correct longitude hour" do
+    @calc.compute_longitude_hour.should eql(BigDecimal.new("-5.0523"))
+  end
+
+  it "returns correct longitude hour" do
+    @calc.compute_set_longitude_hour.should eql(BigDecimal.new("306.9605"))
+  end
+
+  it "returns correct sunset mean anomaly" do
+    @calc.compute_sun_mean_anomaly(BigDecimal.new("306.9605")).should eql(BigDecimal.new("299.2513"))
+  end
+
+  it "returns correct sunset's sun true longitude" do
+    @calc.compute_sun_true_longitude(BigDecimal.new("299.2513")).should eql(BigDecimal.new("220.1966"))
+  end
+
+  it "returns correct sunset's right ascension" do
+    @calc.compute_right_ascension(BigDecimal.new("220.1966")).should eql(BigDecimal.new("37.7890"))
+  end
+
+  it "returns correct sunset's right ascension quadrant" do
+    @calc.put_ra_in_correct_quadrant(BigDecimal.new("220.1966")).should eql(BigDecimal.new("14.5193"))
+  end
+
+  it "returns correct sunset sin sun declination" do
+    @calc.compute_sin_sun_declination(BigDecimal.new("220.1966")).should eql(BigDecimal.new("-0.2568"))
+  end
+
+  it "returns correct sunset cosine sun declination" do
+    @calc.compute_cosine_sun_declination(BigDecimal.new("-0.2541")).should eql(BigDecimal.new("0.9672"))
+  end
+
+  it "returns correct sunset cosine sun local hour" do
+    @calc.compute_cosine_sun_local_hour(BigDecimal.new("220.1966"), 96).should eql(BigDecimal.new("0.0815"))
+  end
+
+  it "returns correct sunset local hour angle" do
+    @calc.compute_sunset_local_hour_angle(BigDecimal.new("0.0815")).should eql(BigDecimal.new("5.6883"))
+  end
+
+  it "returns correct sunset local mean time" do
+    trueLong = BigDecimal.new("220.1966")
+    longHour = BigDecimal.new("-5.0523")
+    localHour = BigDecimal.new("5.6883")
+    t = BigDecimal.new("306.9605")
+    @calc.compute_local_mean_time(trueLong, longHour, t, localHour).should eql(BigDecimal.new("22.4675"))
+  end
+
+  it "returns correct civil sunset time" do
+    @calc.compute_utc_sunset(96).should eql(Time.gm(@date.year, @date.mon, @date.mday, 22, 28))
+  end
+
+  it "returns correct official sunset time" do
+    @calc.compute_utc_sunset(90.8333).should eql(Time.gm(@date.year, @date.mon, @date.mday, 21, 59))
+  end
+
+  it "returns correct nautical sunset time" do
+    @calc.compute_utc_sunset(102).should eql(Time.gm(@date.year, @date.mon, @date.mday, 23, 0))
+  end
+
+  it "returns correct astronomical sunset time" do
+    @calc.compute_utc_sunset(108).should eql(Time.gm(@date.year, @date.mon, @date.mday, 23, 31))
+  end
+end
+
+describe SolarEventCalculator, "test the math for areas where the sun doesn't set" do
+
+  it "returns correct time" do
+    date = Date.parse('2008-04-25') #25 April 2008
+    calc = SolarEventCalculator.new(date, BigDecimal.new("64.8378"), BigDecimal.new("-147.7164"))
+    calc.compute_utc_sunset(108).should eql(nil)
+  end
+
+  it "returns correct time" do
+    date = Date.parse('2008-04-25') #25 April 2008
+    calc = SolarEventCalculator.new(date, BigDecimal.new("64.8378"), BigDecimal.new("-147.7164"))
+    calc.compute_utc_sunset(102).should eql(nil)
+  end
+end
+

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: RubySunrise
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mike Reedell / LuckyCatLabs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-08 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mike@luckycatlabs.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- rubysunrise.gemspec
+- lib/sunrise.rb
+has_rdoc: true
+homepage: http://www.luckycatlabs.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Calculate the sunrise/sunset given lat/long coordinates and the date.  Computes civil, official, nautical, and astronomical sunrise/sunset.
+test_files: 
+- test/sunrisetest.rb
+- test/sunsettest.rb