light travel time astropy

• next »
• « previous |
• Astropy v3.0.dev19489 »
• Time and Dates ( astropy.time ) »

Bases: astropy.utils.misc.ShapedLikeNDArray

Represent and manipulate times and dates for astronomy.

A Time object is initialized with one or more times in the val argument. The input times in val must conform to the specified format and must correspond to the specified time scale . The optional val2 time input should be supplied only for numeric input formats (e.g. JD) where very high precision (better than 64-bit precision) is required.

The allowed values for format can be listed with:

Attributes Summary

Methods Summary

Attributes Documentation

Dict of time formats

List of time scales

Return an instance with the data transposed.

Parameters are as for T . All internal data are views of the data of the original.

Return the cache associated with this instance.

TDB - TT time scale offset

UT1 - UTC time scale offset

Get or set time format.

The format defines the way times are represented when accessed via the .value attribute. By default it is the same as the format used for initializing the Time instance, but it can be set to any other value that could be used for initialization. These can be listed with:

Unix wildcard pattern to select subformats for parsing string input times.

Container for meta information like name, description, format. This is required when the object is used as a mixin column within a table, but can be used as a general way to store meta information.

First of the two doubles that internally store time value(s) in JD.

Second of the two doubles that internally store time value(s) in JD.

The number of dimensions of the instance and underlying arrays.

Unix wildcard pattern to select subformats for outputting times.

Decimal precision when outputting seconds as floating point (int value between 0 and 9 inclusive).

The shape of the time instances.

Like shape , can be set to a new shape by assigning a tuple. Note that if different instances share some but not all underlying data, setting the shape of one instance can make the other instance unusable. Hence, it is strongly recommended to get new, reshaped instances with the reshape method.

The size of the object, as calculated from its shape.

Time value(s) in current format

Methods Documentation

Return indices of the maximum values along the given axis.

This is similar to argmax() , but adapted to ensure that the full precision given by the two doubles jd1 and jd2 is used. See argmax() for detailed documentation.

Return indices of the minimum values along the given axis.

This is similar to argmin() , but adapted to ensure that the full precision given by the two doubles jd1 and jd2 is used. See argmin() for detailed documentation.

Returns the indices that would sort the time array.

This is similar to argsort() , but adapted to ensure that the full precision given by the two doubles jd1 and jd2 is used, and that corresponding attributes are copied. Internally, it uses lexsort() , and hence no sort method can be chosen.

Return a fully independent copy the Time object, optionally changing the format.

If format is supplied then the time format of the returned Time object will be set accordingly, otherwise it will be unchanged from the original.

In this method a full copy of the internal time arrays will be made. The internal time arrays are normally not changeable by the user so in most cases the replicate() method should be used.

Return an instance with the specified diagonals.

Parameters are as for diagonal() . All internal data are views of the data of the original.

Return a copy with the array collapsed into one dimension.

Parameters are as for flatten() .

Find UT1 - UTC differences by interpolating in IERS Table.

In normal usage, UT1-UTC differences are calculated automatically on the first instance ut1 is needed.

To check in code whether any times are before the IERS table range:

Light travel time correction to the barycentre or heliocentre.

The frame transformations used to calculate the location of the solar system barycentre and the heliocentre rely on the erfa routine epv00, which is consistent with the JPL DE405 ephemeris to an accuracy of 11.2 km, corresponding to a light travel time of 4 microseconds.

The routine assumes the source(s) are at large distance, i.e., neglects finite-distance effects.

Maximum along a given axis.

This is similar to max() , but adapted to ensure that the full precision given by the two doubles jd1 and jd2 is used, and that corresponding attributes are copied.

Note that the out argument is present only for compatibility with np.max ; since Time instances are immutable, it is not possible to have an actual out to store the result in.

Minimum along a given axis.

This is similar to min() , but adapted to ensure that the full precision given by the two doubles jd1 and jd2 is used, and that corresponding attributes are copied.

Note that the out argument is present only for compatibility with np.min ; since Time instances are immutable, it is not possible to have an actual out to store the result in.

Creates a new object corresponding to the instant in time this method is called.

“Now” is determined using the utcnow function, so its accuracy and precision is determined by that function. Generally that means it is set by the accuracy of your system clock.

Peak to peak (maximum - minimum) along a given axis.

This is similar to ptp() , but adapted to ensure that the full precision given by the two doubles jd1 and jd2 is used.

Note that the out argument is present only for compatibility with ptp ; since Time instances are immutable, it is not possible to have an actual out to store the result in.

Return an instance with the array collapsed into one dimension.

Parameters are as for ravel() . Note that it is not always possible to unravel an array without copying the data. If you want an error to be raise if the data is copied, you should should assign shape (-1,) to the shape attribute.

Return a replica of the Time object, optionally changing the format.

If copy is set to True then a full copy of the internal time arrays will be made. By default the replica will use a reference to the original arrays when possible to save memory. The internal time arrays are normally not changeable by the user so in most cases it should not be necessary to set copy to True .

The convenience method copy() is available in which copy is True by default.

Returns an instance containing the same data with a new shape.

Parameters are as for reshape() . Note that it is not always possible to change the shape of an array without copying the data (see reshape() documentation). If you want an error to be raise if the data is copied, you should assign the new shape to the shape attribute (note: this may not be implemented for all classes using ShapedLikeNDArray ).

Calculate sidereal time.

Return a copy sorted along the specified axis.

This is similar to sort() , but internally uses indexing with lexsort() to ensure that the full precision given by the two doubles jd1 and jd2 is kept, and that corresponding attributes are properly sorted and copied as well.

Return an instance with single-dimensional shape entries removed

Parameters are as for squeeze() . All internal data are views of the data of the original.

Return an instance with the given axes interchanged.

Parameters are as for swapaxes() : axis1, axis2 . All internal data are views of the data of the original.

Return a new instance formed from the elements at the given indices.

Parameters are as for take() , except that, obviously, no output array can be given.

Convert to (potentially timezone-aware) datetime object.

If timezone is not None , return a timezone-aware datetime object.

Parameters are as for transpose() . All internal data are views of the data of the original.

Page Contents

Skyfield: Home • Table of Contents • Changelog • API Reference

API Reference — Astronomical Positions ¶

See Positions for a detailed guide to these various kinds of position that Skyfield can compute, and to the selection of coordinate systems that can be used to express them.

Generic ICRF position ¶

An ( x,y,z ) position and velocity oriented to the ICRF axes.

The International Celestial Reference Frame (ICRF) is a permanent reference frame that is the replacement for J2000. Their axes agree to within 0.02 arcseconds. It also supersedes older equinox-based systems like B1900 and B1950.

Each instance of this class provides a .position vector and a .velocity vector that specify ( x,y,z ) coordinates along the axes of the ICRF. A specific time .t might be specified or might be None .

The Time coordinate of this position.

A Distance object offering the position’s ( x,y,z ) coordinates.

A Velocity object offering the velocity’s ( dx/dt,dy/dt,dz/dt ) coordinates.

This attribute will have the value None if no velocity was specified for this position.

Constructor: build a position from two vectors in a reference frame.

• t — The Time of the position.
• frame — A reference frame listed at Coordinates in other reference frames .
• distance — A Distance ( x,y,z ) vector in the given frame.
• velocity — A Velocity ẋ,ẏ,ż vector in the given frame.

Compute the distance from the origin to this position.

The return value is a Distance that prints itself out in astronomical units (au) but that also offers attributes au , km , and m if you want to access its magnitude as a number.

Compute the magnitude of the velocity vector.

Length of this vector in days of light travel time.

Compute equatorial RA, declination, and distance.

When called without a parameter, this returns standard ICRF right ascension and declination:

If you instead want the coordinates referenced to the dynamical system defined by the Earth’s true equator and equinox, provide a specific epoch time.

To get J2000.0 coordinates, simply pass ts.J2000 .

Compute hour angle, declination, and distance.

Returns a tuple of two Angle objects plus the Distance to the target. The angles are the hour angle (±12 hours) east or west of your meridian along the ITRS celestial equator, and the declination (±90 degees) above or below it. This only works for positions whose center is a geographic location; otherwise, there is no local meridian from which to measure the hour angle.

Because this declination is measured from the plane of the Earth’s physical geographic equator, it will be slightly different than the declination returned by radec() if you have loaded a Precession and Nutation file.

The coordinates are not adjusted for atmospheric refraction near the horizon.

Compute (alt, az, distance) relative to the observer’s horizon

The altitude returned is an Angle measured in degrees above the horizon, while the azimuth Angle measures east along the horizon from geographic north (so 0 degrees means north, 90 is east, 180 is south, and 270 is west).

By default, Skyfield does not adjust the altitude for atmospheric refraction. If you want Skyfield to estimate how high the atmosphere might lift the body’s image, give the argument temperature_C either the temperature in degrees centigrade, or the string 'standard' (in which case 10°C is used).

When calculating refraction, Skyfield uses the observer’s elevation above sea level to estimate the atmospheric pressure. If you want to override that value, simply provide a number through the pressure_mbar parameter.

Return the angle between this position and another.

You can also compute separations across an array of positions.

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.

Get spherical CIRS coordinates at a given epoch (ra, dec, distance).

Return this position as an ( x,y,z ) vector in a reference frame.

Returns a Distance object giving the ( x,y,z ) of this position in the given frame . See Coordinates in other reference frames .

Return ( x,y,z ) position and velocity vectors in a reference frame.

Returns two vectors in the given coordinate frame : a Distance providing an ( x,y,z ) position and a Velocity giving (xdot,ydot,zdot) velocity. See Coordinates in other reference frames .

Return longitude, latitude, and distance in the given frame.

Returns a 3-element tuple giving the latitude and longitude as Angle objects and the range to the target as a Distance . See Coordinates in other reference frames .

Return a reference frame longitude, latitude, range, and rates.

Return a 6-element tuple of 3 coordinates and 3 rates-of-change for this position in the given reference frame :

• Latitude Angle from +90° north to −90° south
• Longitude Angle 0°–360° east
• Radial Distance
• Latitude AngleRate
• Longitude AngleRate
• Radial Velocity

If the reference frame is the ICRS, or is J2000, or otherwise involves the celestial equator and pole, then the latitude and longitude returned will measure what are more commonly called “declination” and “right ascension”. Note that right ascension is usually expressed as hours (24 in a circle), rather than in the degrees that this routine will return.

Convert this distance to an AstroPy SkyCoord object.

Currently, this will only work with Skyfield positions whose center is the Solar System barycenter or else the geocenter.

Return this position’s phase angle: the angle Sun-target-observer.

Given a Sun object (which you can build by loading an ephemeris and looking up eph['Sun'] ), return the Angle from the body’s point of view between light arriving from the Sun and the light departing toward the observer. This angle is 0° if the observer is in the same direction as the Sun and sees the body as fully illuminated, and 180° if the observer is behind the body and sees only its dark side.

New in version 1.42.

Return the fraction of the target’s disc that is illuminated.

Given a Sun object (which you can build by loading an ephemeris and looking up eph['Sun'] ), compute what fraction from 0.0 to 1.0 of this target’s disc is illuminated, under the assumption that the target is a sphere.

Return whether a position in Earth orbit is in sunlight.

Returns True or False , or an array of such values, to indicate whether this position is in sunlight or is blocked by the Earth’s shadow. It should work with positions produced either by calling at() on a satellite object, or by calling at() on the relative position sat - topos of a satellite with respect to an Earth observer’s position. See Find when a satellite is in sunlight .

Return whether the Earth blocks the view of this object.

For a position centered on an Earth-orbiting satellite, return whether the target is in eclipse behind the disc of the Earth. See Find whether the Earth blocks a satellite’s view .

Generate an Apparent position from an altitude and azimuth.

The altitude and azimuth can each be provided as an Angle object, or else as a number of degrees provided as either a float or a tuple of degrees, arcminutes, and arcseconds:

The distance should be a Distance object, if provided; otherwise a default of 0.1 au is used.

Position measured from the Solar System barycenter ¶

An ( x,y,z ) position measured from the Solar System barycenter.

Skyfield generates a Barycentric position measured from the gravitational center of the Solar System whenever you ask a body for its location at a particular time:

This class’s .position and .velocity are ( x,y,z ) vectors in the Barycentric Celestial Reference System (BCRS), the modern replacement for J2000 coordinates measured from the Solar System Barycenter.

This class inherits the methods of is parent class ICRF as well as the orientation of its axes in space.

Compute the Astrometric position of a body from this location.

To compute the body’s astrometric position, it is first asked for its position at the time t of this position itself. The distance to the body is then divided by the speed of light to find how long it takes its light to arrive. Finally, the light travel time is subtracted from t and the body is asked for a series of increasingly exact positions to learn where it was when it emitted the light that is now reaching this position.

Astrometric position relative to an observer ¶

An astrometric ( x,y,z ) position relative to a particular observer.

The astrometric position of a body is its position relative to an observer, adjusted for light-time delay. It is the position of the body back when it emitted (or reflected) the light that is now reaching the observer’s eye or telescope. Astrometric positions are usually generated in Skyfield by calling the Barycentric method observe() , which performs the light-time correction.

Both the .position and .velocity are ( x,y,z ) vectors oriented along the axes of the ICRF, the modern replacement for the J2000 reference frame.

It is common to either call .radec() (with no argument) on an astrometric position to generate an astrometric place right ascension and declination with respect to the ICRF axes, or else to call .apparent() to generate an Apparent position.

Compute an Apparent position for this body.

This applies two effects to the position that arise from relativity and shift slightly where the other body will appear in the sky: the deflection that the image will experience if its light passes close to large masses in the Solar System, and the aberration of light caused by the observer’s own velocity.

These transforms convert the position from the BCRS reference frame of the Solar System barycenter and to the reference frame of the observer. In the specific case of an Earth observer, the output reference frame is the GCRS.

Apparent position relative to an observer ¶

An apparent ( x,y,z ) position relative to a particular observer.

This class’s vectors provide the position and velocity of a body relative to an observer, adjusted to predict where the body’s image will really appear (hence “apparent”) in the sky:

• Light-time delay, as already present in an Astrometric position.
• Deflection: gravity bends light, and thus the image of a distant object, as the light passes massive objects like Jupiter, Saturn, and the Sun. For an observer on the Earth’s surface or in Earth orbit, the slight deflection by the gravity of the Earth itself is also included.
• Aberration: incoming light arrives slanted because of the observer’s motion through space.

These positions are usually produced in Skyfield by calling the apparent() method of an Astrometric object.

Both the .position and .velocity are ( x,y,z ) vectors oriented along the axes of the ICRF, the modern replacement for the J2000 reference frame. If the observer is at the geocenter, they are more specifically GCRS coordinates. Two common coordinates that this vector can generate are:

• Proper place: call .radec() without arguments to compute right ascension and declination with respect to the fixed axes of the ICRF.
• Apparent place, the most popular option: call .radec('date') to generate right ascension and declination with respect to the equator and equinox of date.

Geocentric position relative to the Earth ¶

An ( x,y,z ) position measured from the center of the Earth.

A geocentric position is the difference between the position of the Earth at a given instant and the position of a target body at the same instant, without accounting for light-travel time or the effect of relativity on the light itself.

Its .position and .velocity vectors have ( x,y,z ) axes that are those of the Geocentric Celestial Reference System (GCRS), an inertial system that is an update to J2000 and that does not rotate with the Earth itself.

Deprecated; instead, call .frame_xyz(itrs) . See Coordinates in other reference frames .

Deprecated; instead, call either iers2010.subpoint(pos) or wgs84.subpoint(pos) .

Building a position from right ascension and declination ¶

Build a position object from a right ascension and declination.

If a specific distance_au is not provided, Skyfield returns a position vector a gigaparsec in length. This puts the position at a great enough distance that it will stand at the same right ascension and declination from any viewing position in the Solar System, to very high precision (within a few hundredths of a microarcsecond).

If an epoch is specified, the input coordinates are understood to be in the dynamical system of that particular date. Otherwise, they will be assumed to be ICRS (the modern replacement for J2000).

New in version 1.21: This replaces a deprecated function position_from_radec() whose distance argument was not as well designed.

• next »
• « previous |
• Astropy v1.0.4 »
• Cosmological Calculations ( astropy.cosmology ) »

Bases: astropy.cosmology.core.Cosmology

A class describing an isotropic and homogeneous (Friedmann-Lemaitre-Robertson-Walker) cosmology.

This is an abstract base class – you can’t instantiate examples of this class, but must work with one of its subclasses such as LambdaCDM or wCDM .

Class instances are static – you can’t change the values of the parameters. That is, all of the attributes above are read only.

Attributes Summary

Methods Summary

Attributes Documentation

Return the Hubble constant as an Quantity at z=0

Number of effective neutrino species

Omega baryon; baryonic matter density/critical density at z=0

Omega dark energy; dark energy density/critical density at z=0

Omega dark matter; dark matter density/critical density at z=0

Omega gamma; the density/critical density of photons at z=0

Omega curvature; the effective curvature density/critical density at z=0

Omega matter; matter density/critical density at z=0

Omega nu; the density/critical density of neutrinos at z=0

Temperature of the CMB as Quantity at z=0

Temperature of the neutrino background as Quantity at z=0

Critical density as Quantity at z=0

Dimensionless Hubble constant: h = H_0 / 100 [km/sec/Mpc]

Does this cosmology have at least one massive neutrino species?

Hubble distance as Quantity

Hubble time as Quantity

Mass of neutrino species

Methods Documentation

Hubble parameter (km/s/Mpc) at redshift z .

Return the density parameter for baryonic matter at redshift z .

Return the density parameter for dark energy at redshift z .

Return the density parameter for dark matter at redshift z .

Return the density parameter for photons at redshift z .

Return the equivalent density parameter for curvature at redshift z .

Return the density parameter for non-relativistic matter at redshift z .

Return the density parameter for massless neutrinos at redshift z .

Return the CMB temperature at redshift z .

Return the neutrino temperature at redshift z .

Absorption distance at redshift z .

This is used to calculate the number of objects with some cross section of absorption and number density intersecting a sightline per unit redshift path.

Hogg 1999 Section 11. (astro-ph/9905116) Bahcall, John N. and Peebles, P.J.E. 1969, ApJ, 156L, 7B

Age of the universe in Gyr at redshift z .

Angular diameter distance in Mpc at a given redshift.

This gives the proper (sometimes called ‘physical’) transverse distance corresponding to an angle of 1 radian for an object at redshift z .

Weinberg, 1972, pp 421-424; Weedman, 1986, pp 65-67; Peebles, 1993, pp 325-327.

Angular diameter distance between objects at 2 redshifts. Useful for gravitational lensing.

This method only works for flat or open curvature (omega_k >= 0).

Angular separation in arcsec corresponding to a comoving kpc at redshift z .

Angular separation in arcsec corresponding to a proper kpc at redshift z .

Returns a copy of this object, potentially with some changes.

This assumes that the values of all constructor arguments are available as properties, which is true of all the provided subclasses but may not be true of user-provided ones. You can’t change the type of class, so this can’t be used to change between flat and non-flat. If no modifications are requested, then a reference to this object is returned.

To make a copy of the Planck13 cosmology with a different Omega_m and a new name:

Comoving line-of-sight distance in Mpc at a given redshift.

The comoving distance along the line-of-sight between two objects remains constant with time for objects in the Hubble flow.

Comoving transverse distance in Mpc at a given redshift.

This value is the transverse comoving distance at redshift z corresponding to an angular separation of 1 radian. This is the same as the comoving distance if omega_k is zero (as in the current concordance lambda CDM model).

This quantity also called the ‘proper motion distance’ in some texts.

Comoving volume in cubic Mpc at redshift z .

This is the volume of the universe encompassed by redshifts less than z . For the case of omega_k = 0 it is a sphere of radius comoving_distance but it is less intuitive if omega_k is not 0.

Critical density in grams per cubic cm at redshift z .

Evaluates the redshift dependence of the dark energy density.

It will generally helpful for subclasses to overload this method if the integral can be done analytically for the particular dark energy equation of state that they implement.

Differential comoving volume at redshift z.

Useful for calculating the effective comoving volume. For example, allows for integration over a comoving volume that has a sensitivity function that changes with redshift. The total comoving volume is given by integrating differential_comoving_volume to redshift z and multiplying by a solid angle.

Distance modulus at redshift z .

The distance modulus is defined as the (apparent magnitude - absolute magnitude) for an object at redshift z .

Function used to calculate H(z), the Hubble parameter.

It is not necessary to override this method, but if de_density_scale takes a particularly simple form, it may be advantageous to.

Inverse of efunc.

Separation in transverse comoving kpc corresponding to an arcminute at redshift z .

Separation in transverse proper kpc corresponding to an arcminute at redshift z .

The lookback distance is the light travel time distance to a given redshift. It is simply c * lookback_time. It may be used to calculate the proper distance between two redshifts, e.g. for the mean free path to ionizing radiation.

Lookback time in Gyr to redshift z .

The lookback time is the difference between the age of the Universe now and the age at redshift z .

Luminosity distance in Mpc at redshift z .

This is the distance to use when converting between the bolometric flux from an object at redshift z and its bolometric luminosity.

Weinberg, 1972, pp 420-424; Weedman, 1986, pp 60-62.

Neutrino density function relative to the energy density in photons.

The density in neutrinos is given by

Scale factor at redshift z .

The dark energy equation of state.

This must be overridden by subclasses.

Page Contents

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement . We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Calculating TESS BJD to HJD Accounting for Light Time Travel #2702

kjkoeller commented Apr 7, 2023

mkelley commented May 4, 2023

Sorry, something went wrong.

kjkoeller commented May 4, 2023

Mkelley commented may 4, 2023 • edited, kjkoeller commented may 5, 2023, mkelley commented may 5, 2023, kjkoeller commented may 7, 2023 • edited.

bsipocz commented May 8, 2023

kjkoeller commented May 8, 2023

• 👍 1 reaction

No branches or pull requests