def test_angle_to_positive(): """Tests the to_positive() method""" a = Angle(-87.32) b = Angle(87.32) assert abs(a.to_positive()() - 272.68) < TOL, \ "ERROR: In 1st to_positive() test, value doesn't match" assert abs(b.to_positive()() - 87.32) < TOL, \ "ERROR: In 2nd to_positive() test, value doesn't match"
def true_longitude_coarse(epoch): """This method provides the Sun's true longitude with a relatively low accuracy of about 0.01 degree. :param epoch: Epoch to compute the position of the Sun :type epoch: :py:class:`Epoch` :returns: A tuple containing the true (ecliptical) longitude (as an Angle object) and the radius vector in astronomical units. :rtype: tuple :raises: TypeError if input value is of wrong type. >>> epoch = Epoch(1992, 10, 13) >>> true_lon, r = Sun.true_longitude_coarse(epoch) >>> print(true_lon.dms_str(n_dec=0)) 199d 54' 36.0'' >>> print(round(r, 5)) 0.99766 """ # First check that input values are of correct types if not (isinstance(epoch, Epoch)): raise TypeError("Invalid input type") # Compute the time in Julian centuries t = (epoch - JDE2000) / 36525.0 # Compute the geometric mean longitude of the Sun l0 = 280.46646 + t * (36000.76983 + t * 0.0003032) l0 = Angle(l0) l0.to_positive() # Now, compute the mean anomaly of the Sun m = 357.52911 + t * (35999.05029 - t * 0.0001537) m = Angle(m) mrad = m.rad() # The eccentricity of the Earth's orbit e = 0.016708634 - t * (0.000042037 + t * 0.0000001267) # Equation of the center c = ((1.914602 - t * (0.004817 + t * 0.000014)) * sin(mrad) + (0.019993 - t * 0.000101) * sin(2.0 * mrad) + 0.000289 * sin(3.0 * mrad)) c = Angle(c) true_lon = l0 + c true_anom = m + c # Sun's radius vector r = (1.000001018 * (1.0 - e * e)) / (1.0 + e * cos(true_anom.rad())) return (true_lon, r)
def apparent_rightascension_declination_coarse(epoch): """This method provides the Sun's apparent right ascension and declination with a relatively low accuracy of about 0.01 degree. :param epoch: Epoch to compute the position of the Sun :type epoch: :py:class:`Epoch` :returns: A tuple containing the right ascension and the declination (as Angle objects) and the radius vector in astronomical units. :rtype: tuple :raises: TypeError if input value is of wrong type. >>> epo = Epoch(1992, 10, 13) >>> ra, delta, r = Sun.apparent_rightascension_declination_coarse(epo) >>> print(ra.ra_str(n_dec=1)) 13h 13' 31.4'' >>> print(delta.dms_str(n_dec=0)) -7d 47' 6.0'' >>> print(round(r, 5)) 0.99766 """ # First check that input values are of correct types if not isinstance(epoch, Epoch): raise TypeError("Invalid input type") # Second, find the apparent longitude sun = Sun() app_lon, r = sun.apparent_longitude_coarse(epoch) # Compute the obliquity of the ecliptic e0 = mean_obliquity(epoch) # Compute the time in Julian centuries t = (epoch - JDE2000) / 36525.0 # Then correct for nutation and aberration omega = 125.04 - 1934.136 * t omega = Angle(omega) # Correct the obliquity e = e0 + 0.00256 * cos(omega.rad()) alpha = atan2(cos(e.rad()) * sin(app_lon.rad()), cos(app_lon.rad())) alpha = Angle(alpha, radians=True) alpha.to_positive() delta = asin(sin(e.rad()) * sin(app_lon.rad())) delta = Angle(delta, radians=True) return (alpha, delta, r)
def equation_of_time(epoch): """This method computes the equation of time for a given epoch, understood as the difference between apparent and mean time, or the difference between the hour angle of the true Sun and the mean Sun. :param epoch: Epoch to compute the equation of time, as an Epoch object :type epoch: :py:class:`Epoch` :returns: Difference between apparent and mean time, as a tuple, in minutes (int) and seconds (float) of time :rtype: tuple :raises: TypeError if input values are of wrong type. >>> epoch = Epoch(1992, 10, 13.0) >>> m, s = Sun.equation_of_time(epoch) >>> print(m) 13 >>> print(round(s, 1)) 42.6 """ # First check that input values are of correct types if not isinstance(epoch, Epoch): raise TypeError("Invalid input type") # Compute time in Julian millenia from J2000.0 t = (epoch - JDE2000) / 365250 l0 = (280.4664567 + t * (360007.6982779 + t * (0.03032028 + t * (1.0 / 49931.0 + t * (-1.0 / 15300.0 - t * 1.0 / 2000000.0))))) l0 = Angle(l0) l0 = l0.to_positive() # Compute the apparent position of the Sun lon, lat, r = Sun.apparent_geocentric_position(epoch) # Now, get the true obliquity epsilon = true_obliquity(epoch) # Transform from eclliptical to equatorial coordinates alpha, dec = ecliptical2equatorial(lon, lat, epsilon) alpha = alpha.to_positive() # Now we need the nutation in longitude deltapsi = nutation_longitude(epoch) e = l0() - 0.0057183 - alpha + deltapsi * cos(epsilon.rad()) e *= 4.0 # Extract seconds s = (abs(e()) % 1) * 60.0 m = int(e()) return m, s
def geocentric_position(epoch): """This method computes the geocentric position of Pluto (right ascension and declination) for the given epoch, for the standard equinox J2000.0. :param epoch: Epoch to compute geocentric position, as an Epoch object :type epoch: :py:class:`Epoch` :returns: A tuple containing the right ascension and the declination as Angle objects :rtype: tuple :raises: TypeError if input value is of wrong type. :raises: ValueError if input epoch outside the 1885-2099 range. >>> epoch = Epoch(1992, 10, 13.0) >>> ra, dec = Pluto.geocentric_position(epoch) >>> print(ra.ra_str(n_dec=1)) 15h 31' 43.7'' >>> print(dec.dms_str(n_dec=0)) -4d 27' 29.0'' """ # First check that input value is of correct types if not isinstance(epoch, Epoch): raise TypeError("Invalid input type") # Check that the input epoch is within valid range y = epoch.year() if y < 1885.0 or y > 2099.0: raise ValueError("Epoch outside the 1885-2099 range") # Compute the heliocentric position of Pluto ll, b, r = Pluto.geometric_heliocentric_position(epoch) # Change angles to radians ll = ll.rad() b = b.rad() # Values corresponding to obliquity of ecliptic (epsilon) for J2000.0 sine = 0.397777156 cose = 0.917482062 x = r * cos(ll) * cos(b) y = r * (sin(ll) * cos(b) * cose - sin(b) * sine) z = r * (sin(ll) * cos(b) * sine + sin(b) * cose) # Compute Sun's J2000.0 rectacngular coordinates xs, ys, zs = Sun.rectangular_coordinates_j2000(epoch) # Compute auxiliary quantities xi = x + xs eta = y + ys zeta = z + zs # Compute Pluto's distance to Earth delta = sqrt(xi * xi + eta * eta + zeta * zeta) # Get the light-time difference tau = 0.0057755183 * delta # Repeat the computations using the light-time correction ll, b, r = Pluto.geometric_heliocentric_position(epoch - tau) # Change angles to radians ll = ll.rad() b = b.rad() x = r * cos(ll) * cos(b) y = r * (sin(ll) * cos(b) * cose - sin(b) * sine) z = r * (sin(ll) * cos(b) * sine + sin(b) * cose) # Compute auxiliary quantities xi = x + xs eta = y + ys zeta = z + zs # Compute Pluto's distance to Earth delta = sqrt(xi * xi + eta * eta + zeta * zeta) # Compute right ascension and declination alpha = Angle(atan2(eta, xi), radians=True) dec = Angle(asin(zeta / delta), radians=True) return alpha.to_positive(), dec