def test_0(self):
        dat = astrodate.AstroDate()
        dat.set_longitude(self.lng0)
        dat.set_zone_correction(self.zc0)
        dat.set_daylight_savings(self.dst0)

        dat.set_with_tuple(self.lct0)
        d = dat.to_lct(self.zc0_1, self.dst0_1)
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lct0)
        t = d.get_tuple()
        self.assertTupleEqual(t, self.lct0_1)

        d = dat.to_lct(self.zc0_2, self.dst0_2)
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lct0)
        t = d.get_tuple()
        self.assertTupleEqual(t, self.lct0_2)
                
        dat.to_utc()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.utc0)

        dat.to_lct()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lct0)
    def test_to_date_tuple_from_julian(self):
        dat = astrodate.AstroDate()

        dat.set_with_julian(0.0)
        d = dat.get_tuple()
        self.assertTupleEqual(d, (-4712, 1, 1, 12, 0, 0, 'utc'))

        dat.set_with_julian(2299160.5)
        d = dat.get_tuple()
        self.assertTupleEqual(d, (1582, 10, 15, 0, 0, 0, 'utc'))

        dat.set_with_julian(2448251.3125)
        d = dat.get_tuple()
        self.assertTupleEqual(d, (1990, 12, 25, 19, 30, 0, 'utc'))

        dat.set_with_julian(2448988.5)
        d = dat.get_tuple()
        self.assertTupleEqual(d, (1993, 1, 1, 0, 0, 0, 'utc'))

        dat.set_with_julian(2448989.0)
        d = dat.get_tuple()
        self.assertTupleEqual(d, (1993, 1, 1, 12, 0, 0, 'utc'))

        dat.set_with_julian(2449078.5)
        d = dat.get_tuple()
        self.assertTupleEqual(d, (1993, 4, 1, 0, 0, 0, 'utc'))

        dat.set_with_julian(2451545.0)
        d = dat.get_tuple()
        self.assertTupleEqual(d, (2000, 1, 1, 12, 0, 0, 'utc'))
 def test_ref2(self):
     dat = astrodate.AstroDate()
     dat.set_longitude(self.lng_ref2)
     
     dat.set_with_tuple(self.utc_ref2)
     dat.to_lst()
     t = dat.get_tuple()
     self.assertTupleEqual(t, self.lst_ref2)
 def calculate_mean_obliquity(self, epochTD=None):
     if epochTD is not None:
         d = astrodate.AstroDate().alloc_with_epochTD(epochTD)
     else:
         if self.date is None:
             raise ValueError, "Date (TD) is required!"
         self.date.to_tdt()
         d = self.date
     n = earth.Nutation()
     n.calculate_with_julianTD(d.get_julian())
     return n.get_mean_obliquity()
    def test_equatorial_to_ecliptic(self):
        d = astrodate.AstroDate().alloc_with_julian(astrodate.J1950, "tdt")
        c = AstroCoord()
        c.set_date(d)

        c.set_with_tuple((9, 34, 53.6, 19, 32, 14.2, u'equ|hrs|ra'))
        # print(c.get_pretty_coordinate())

        c.to_ecliptic()
        # print(c.get_pretty_coordinate())
        t = c.get_tuple()
        self.assertTupleEqual(t, (139, 41, 9.29, 4, 52, 22.00, u'ecl'))
    def test_equatorial_to_galactic(self):
        d = astrodate.AstroDate().alloc_with_julian(astrodate.J1950, "tdt")
        c = AstroCoord()
        c.set_date(d)

        c.set_with_tuple((10, 21, 0.0, 10, 3, 11, u'equ|hrs|ra'))
        # print(c.get_pretty_coordinate())

        c.to_galactic()
        # print(c.get_pretty_coordinate())
        t = c.get_tuple()
        self.assertTupleEqual(t, (232, 14, 52.51, 51, 7, 20.16, u'gal'))
    def test_ecliptic_to_equatorial(self):
        d = astrodate.AstroDate().alloc_with_julian(astrodate.J1950, "tdt")
        c = AstroCoord()
        c.set_date(d)

        c.set_with_tuple((139, 41, 10, 4, 52, 31, u'ecl'))
        # print(c.get_pretty_coordinate())

        c.to_equatorial(1980.0)
        # print(c.get_pretty_coordinate())
        t = c.get_tuple()
        self.assertTupleEqual(t, (9, 34, 53.58, 19, 32, 14.18, u'equ|hrs|ra'))
    def test_horizon_to_equatorial(self):
        c = AstroCoord()
        c.set_latitude(52.0)

        c.set_with_tuple((19, 20, 3.64, 283, 16, 15.7, u'hor'))
        # print(c.get_pretty_coordinate())

        c.to_equatorial()
        # print(c.get_pretty_coordinate())
        t = c.get_tuple()
        self.assertTupleEqual(t, (5, 51, 44.00, 23, 13, 10.0, 'equ|hrs|ha'))

        # print

        d = astrodate.AstroDate()
        d.set_with_tuple((2017, 1, 1, 0, 0, 0.0, u'lst'))
        c.set_latitude(31.9583)
        c.set_date(d)

        c.set_with_tuple((77, 21, 40.56, 39, 33, 35.22, u'hor'))
        # print(c.get_pretty_coordinate())

        c.to_equatorial()
        # print(c.get_pretty_coordinate())
        t = c.get_tuple()
        self.assertTupleEqual(t, (23, 17, 15.7, 41, 16, 9.02, 'equ|hrs|ha'))
        c.to_right_ascension()
        # print(c.get_pretty_coordinate())
        c.to_degrees()
        # print(c.get_pretty_coordinate())
        t = c.get_tuple()
        self.assertTupleEqual(t, (10, 41, 4.50, 41, 16, 9.02, 'equ|deg|ra'))

        # print

        d.set_longitude(-1.9166667)
        d.set_with_tuple((1998, 8, 10, 23, 10, 00, u'utc'))
        d.to_lst()
        c.set_latitude(52.5)
        c.set_date(d)

        c.set_with_tuple((49, 10, 7.93, 269, 8, 48.01, u'hor'))
        # print(c.get_pretty_coordinate())

        c.to_equatorial()
        # print(c.get_pretty_coordinate())
        t = c.get_tuple()
        self.assertTupleEqual(t, (3, 37, 31.93, 36, 28, 0.0, 'equ|hrs|ha'))
        c.to_right_ascension()
        # print(c.get_pretty_coordinate())
        t = c.get_tuple()
        self.assertTupleEqual(t, (16, 41, 42.0, 36, 28, 0.0, 'equ|hrs|ra'))
 def test_nutation(self):
     d = astrodate.AstroDate().alloc_with_tuple(
         (1987, 4, 10, 0, 0, 0.0, u'td'))
     jde = d.get_julian()
     n = earth.Nutation()
     n.calculate_with_julianTD(jde)
     nutation_in_longitude = n.get_nutation_in_longitude()
     nutation_in_obliquity = n.get_nutation_in_obliquity()
     mean_obliquity = n.get_mean_obliquity()
     true_obliquity = n.get_true_obliquity()
     self.assertEqual(nutation_in_longitude, -0.001052332550403307)
     self.assertEqual(nutation_in_obliquity, 0.002622947155040129)
     self.assertEqual(mean_obliquity, 23.440946290957324)
     self.assertEqual(true_obliquity, 23.443569238112364)
    def test_equatorial_mode(self):
        d = astrodate.AstroDate()
        d.set_longitude(-64.0)
        d.set_with_tuple((1980, 4, 22, 14, 36, 51.67, u'utc'))
        d.to_lst()
        c = AstroCoord()
        c.set_date(d)

        c.set_with_tuple((18, 32, 21.0, -8, 12, 5.9, u'equ|hrs|ra'))
        # print(Rigel_Equ_Hrs_RA)

        c.to_hour_angle()
        # print(c.get_pretty_coordinate())
        t = c.get_tuple()
        self.assertTupleEqual(t, (5, 51, 44.23, -8, 12, 5.9, u'equ|hrs|ha'))

        c.to_degrees()
        # print(c.get_pretty_coordinate())
        t = c.get_tuple()
        self.assertTupleEqual(t, (87, 56, 3.45, -8, 12, 5.9, u'equ|deg|ha'))
    def test_to_julian_from_date_tuple(self):
        dat = astrodate.AstroDate()

        dat.set_with_tuple((-4712, 1, 1, 12, 0, 0))
        jd = dat.get_julian()
        self.assertEquals(jd, 0.0)

        dat.set_with_tuple((1582, 10, 15))
        jd = dat.get_julian()
        self.assertEquals(jd, 2299160.5)

        dat.set_with_tuple((1980, 2, 17))
        jd = dat.get_julian()
        self.assertEquals(jd, 2444286.5)

        dat.set_with_tuple((1985, 2, 17))
        jd = dat.get_julian()
        self.assertEquals(jd, 2446113.5)

        dat.set_with_tuple((1990, 12, 25, 19, 30, 0))
        jd = dat.get_julian()
        self.assertEquals(jd, 2448251.3125)

        dat.set_with_tuple((1993, 1, 1))
        jd = dat.get_julian()
        self.assertEquals(jd, 2448988.5)

        dat.set_with_tuple((1993, 1, 1, 12, 0, 0))
        jd = dat.get_julian()
        self.assertEquals(jd, 2448989.0)

        dat.set_with_tuple((1993, 4, 1))
        jd = dat.get_julian()
        self.assertEquals(jd, 2449078.5)

        dat.set_with_tuple((2000, 1, 1, 12, 0, 0))
        jd = dat.get_julian()
        self.assertEquals(jd, 2451545.0)
Beispiel #12
0
 def test_crn(self):
     d = astrodate.AstroDate().alloc_with_tuple((1975, 1, 27, 0, 0, 0.0, u'lct'))
     crn = sun.calculate_crn_with_dateTD(d)
     self.assertEqual(crn, 1624)
    def test_2(self):
        dat = astrodate.AstroDate()
        dat.set_longitude(self.lng2)
        dat.set_zone_correction(self.zc2)
        dat.set_daylight_savings(self.dst2)

        dat.set_with_tuple(self.lct2)
        dat.to_lct()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lct2)

        dat.to_utc()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.utc2)

        dat.to_lct()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lct2)

        dat.set_with_tuple(self.utc2)
        dat.to_gst()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.gst2)

        dat.to_utc()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.utc2)

        dat.set_with_tuple(self.gst2)
        dat.to_lst()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lst2)

        dat.to_gst()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.gst2)

        dat.set_with_tuple(self.utc2)
        dat.to_tdt()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.tdt2)

        dat.to_utc()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.utc2)

        dat.set_with_tuple(self.lct2)
        dat.to_lst()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lst2)

        dat.to_lct()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lct2)

        dat.set_with_tuple(self.lct2)
        dat.to_tdt()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.tdt2)

        dat.to_lct()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lct2)
    def test_1(self):
        dat = astrodate.AstroDate()
        dat.set_longitude(self.lng1)
        dat.set_zone_correction(self.zc1)
        dat.set_daylight_savings(self.dst1)

        dat.set_with_tuple(self.lct1)
        d = dat.to_lct(self.zc1_1, self.dst1_1)
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lct1)
        t = d.get_tuple()
        self.assertTupleEqual(t, self.lct1_1)

        d = dat.to_lct(self.zc1_2, self.dst1_2)
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lct1)
        t = d.get_tuple()
        self.assertTupleEqual(t, self.lct1_2)
        
        dat.to_utc()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.utc1)

        dat.to_lct()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lct1)

        dat.set_with_tuple(self.utc1)
        dat.to_gst()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.gst1)

        dat.to_utc()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.utc1)

        dat.set_with_tuple(self.gst1)
        dat.to_lst()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lst1)

        dat.to_gst()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.gst1)

        dat.set_with_tuple(self.utc1)
        dat.to_tdt()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.tdt1)

        dat.to_utc()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.utc1)

        dat.set_with_tuple(self.lct1)
        dat.to_lst()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lst1)

        dat.to_lct()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lct1)

        dat.set_with_tuple(self.lct1)
        dat.to_tdt()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.tdt1)

        dat.to_lct()
        t = dat.get_tuple()
        self.assertTupleEqual(t, self.lct1)
Beispiel #15
0
if __name__ == "__main__":


    jde = 2448908.5
    p = calculate_position_with_julianTD(jde)
    print("Latitude0: {}".format(p.get_latitude0()))
    print("Latitude: {}".format(p.get_latitude()))
    print("Apparent Longitude: {}".format(p.get_apparent_longitude()))
    print("True Longitude0: {}".format(p.get_true_longitude0()))
    print("True Longitude: {}".format(p.get_true_longitude()))
    print("Radius: {}".format(p.get_earth_sun_radius()))
    
    print

    year = 2017
    ad = astrodate.AstroDate().alloc_now_utc()

    jdve = p.calculate_season_start(year, VERNAL_EQUINOX)
    ad.set_with_julian(jdve, astrodate.TIME_MODE_TDT)
    ve = ad.get_pretty_string()
    print("Vernal Equinox: {} ({})".format(ve, jdve))

    jdss = p.calculate_season_start(year, SUMMER_SOLSTICE)
    ad.set_with_julian(jdss, astrodate.TIME_MODE_TDT)
    ss = ad.get_pretty_string()
    print("Summer Solstice: {} ({})".format(ss, jdss))

    jdae = p.calculate_season_start(year, AUTUMNAL_EQUINOX)
    ad.set_with_julian(jdae, astrodate.TIME_MODE_TDT)
    ae = ad.get_pretty_string()
    print("Autumnal Equinox: {} ({})".format(ae, jdae))