# How to use the skyfield.timelib.Time function in skyfield

## To help you get started, we’ve selected a few skyfield examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

skyfielders / python-skyfield / skyfield / timelib.py View on Github
``````Supply the Terrestrial Time (TT) as a proleptic Gregorian
calendar date:

>>> t = ts.tt(2014, 1, 18, 1, 35, 37.5)
>>> t.tt
2456675.56640625
>>> t.tt_calendar()
(2014, 1, 18, 1, 35, 37.5)

"""
if jd is not None:
return self.tt_jd(jd)  # deprecate someday
a = _to_array
whole = julian_day(a(year), a(month), a(day)) - 0.5
fraction = (a(second) + a(minute) * 60.0 + a(hour) * 3600.0) / DAY_S
return Time(self, whole, fraction)
``````
skyfielders / python-skyfield / skyfield / positionlib.py View on Github
``````def cirs_xyz(self, epoch):
"""Compute cartesian CIRS coordinates at a given epoch (x,y,z).

Calculate coordinates in the Celestial Intermediate Reference System
(CIRS), a dynamical coordinate system referenced to the Celestial
Intermediate Origin (CIO). As this is a dynamical system it must be
calculated at a specific epoch.
"""
if isinstance(epoch, Time):
pass
elif isinstance(epoch, float):
epoch = Time(None, tt=epoch)
elif epoch == 'date':
epoch = self.t
else:
raise ValueError('the epoch= must be a Time object,'
' a floating point Terrestrial Time (TT),'
' or the string "date" for epoch-of-date')

vector = mxv(epoch.C, self.position.au)
return Distance(vector)``````
skyfielders / python-skyfield / skyfield / vectorlib.py View on Github
``````def at(self, t):
"""At time ``t``, compute the target's position relative to the center.

If ``t`` is an array of times, then the returned position object
will specify as many positions as there were times.  The kind of
position returned depends on the value of the ``center``
attribute:

* Solar System Barycenter: :class:`~skyfield.positionlib.Barycentric`
* Center of the Earth: :class:`~skyfield.positionlib.Geocentric`
* Difference: :class:`~skyfield.positionlib.Geometric`
* Anything else: :class:`~skyfield.positionlib.ICRF`

"""
if not isinstance(t, Time):
raise ValueError('please provide the at() method with a Time'
' instance as its argument, instead of the'
' value {0!r}'.format(t))
observer_data = ObserverData()
observer_data.ephemeris = self.ephemeris
p, v, observer_data.gcrs_position, message = self._at(t)
center = self.center
if center == 0:
observer_data.bcrs_position = p
observer_data.bcrs_velocity = v
self._snag_observer_data(observer_data, t)
position = build_position(p, v, t, center, self.target, observer_data)
position.message = message
return position``````
skyfielders / python-skyfield / skyfield / starlib.py View on Github
``````self.ra = Angle(hours=ra_hours)
elif isinstance(ra, Angle):
self.ra = ra
else:
raise TypeError('please provide either ra_hours= or else'
' ra=')

if dec_degrees is not None:
self.dec = Angle(degrees=dec_degrees)
elif isinstance(dec, Angle):
self.dec = dec
else:
raise TypeError('please provide either dec_degrees= or else'
' dec=')

if isinstance(epoch, Time):
epoch = epoch.tt
# elif isinstance(epoch, float):
#     pass
# else:
#     raise ValueError('the epoch= must be a Time object, or'
#                      ' a floating point Barycentric Dynamical Time (TDB)')

self.ra_mas_per_year = ra_mas_per_year
self.dec_mas_per_year = dec_mas_per_year
self.parallax_mas = parallax_mas
self.epoch = epoch
self.names = names

self._compute_vectors()``````
skyfielders / python-skyfield / skyfield / timelib.py View on Github
``````def __init__(self, delta_t_recent, leap_dates, leap_offsets):
self.delta_t_table = build_delta_t_table(delta_t_recent)
self.leap_dates, self.leap_offsets = leap_dates, leap_offsets
self._leap_reverse_dates = leap_dates + leap_offsets / DAY_S
self.J2000 = Time(self, float_(T0))
self.B1950 = Time(self, float_(B1950))``````
skyfielders / python-skyfield / skyfield / timelib.py View on Github
``````def tt_jd(self, jd, fraction=0.0):
"""Build a `Time` from a TT Julian date."""
whole, fraction2 = divmod(_to_array(jd), 1.0)
fraction2 += fraction
return Time(self, whole, fraction2)``````
skyfielders / python-skyfield / skyfield / positionlib.py View on Github
``````If you instead want the coordinates referenced to the dynamical
system defined by the Earth's mean equator and equinox, provide
an epoch time.  To get J2000.0 coordinates, for example:

>>> ra, dec, distance = ICRF([1, 2, 3]).radec(ts.J2000)
>>> print(ra, dec, sep='\n')
04h 13m 43.32s
+53deg 17' 55.1"

"""
position_au = self.position.au
if epoch is not None:
if isinstance(epoch, Time):
pass
elif isinstance(epoch, float):
epoch = Time(None, tt=epoch)
elif epoch == 'date':
epoch = self.t
else:
raise ValueError('the epoch= must be a Time object,'
' a floating point Terrestrial Time (TT),'
' or the string "date" for epoch-of-date')
position_au = einsum('ij...,j...->i...', epoch.M, position_au)
r_au, dec, ra = to_polar(position_au)
Distance(r_au))``````
skyfielders / python-skyfield / skyfield / timelib.py View on Github
``````def from_datetime(self, datetime):
"""Return a `Time` for a Python ``datetime``.

The ``datetime`` must be “timezone-aware”: it must have a time
zone object as its ``tzinfo`` attribute instead of ``None``.

"""
jd, fr = _utc_datetime_to_tai(
self.leap_dates, self.leap_offsets, datetime)
t = Time(self, jd, fr + tt_minus_tai)
t.tai_fraction = fr
return t``````
skyfielders / python-skyfield / skyfield / timelib.py View on Github
``````# Estimate TT = UT1, to get a rough Delta T estimate.
tt_approx = ut1
delta_t_approx = interpolate_delta_t(self.delta_t_table, tt_approx)

# Use the rough Delta T to make a much better estimate of TT,
# then generate an even better Delta T.
tt_approx = ut1 + delta_t_approx / DAY_S
delta_t_approx = interpolate_delta_t(self.delta_t_table, tt_approx)

# We can now estimate TT with an error of &lt; 1e-9 seconds within
# 10 centuries of either side of the present; for details, see:
# https://github.com/skyfielders/astronomy-notebooks
# and look for the notebook "error-in-timescale-ut1.ipynb".
delta_t_approx /= DAY_S
t = Time(self, ut1, delta_t_approx)
t.ut1_fraction = 0.0
return t``````

## skyfield

Elegant astronomy for Python

MIT