def send_to_log(message, kind='INFO'):
"""
A simple function to demonstrate the logger generating an origin.
"""
if kind.lower() == 'info':
log.info(message)
elif kind.lower() == 'debug':
log.debug(message)
def send_to_log(message, kind='INFO'):
"""
A simple function to demonstrate the logger generating an origin.
"""
if kind.lower() == 'info':
log.info(message)
elif kind.lower() == 'debug':
log.debug(message)
def get_body_heliographic_stonyhurst(body, time='now', observer=None):
"""
Return a `~sunpy.coordinates.frames.HeliographicStonyhurst` frame for the location of a
solar-system body at a specified time. The location can be corrected for light travel time
to an observer.
Parameters
----------
body : `str`
The solar-system body for which to calculate positions
time : {parse_time_types}
Time to use in a parse_time-compatible format
observer : `~astropy.coordinates.SkyCoord`
If None, the returned coordinate is the instantaneous or "true" location.
If not None, the returned coordinate is the astrometric location (i.e., accounts for light
travel time to the specified observer)
Returns
-------
out : `~sunpy.coordinates.frames.HeliographicStonyhurst`
Location of the solar-system body in the `~sunpy.coordinates.HeliographicStonyhurst` frame
Notes
-----
There is no correction for aberration due to observer motion. For a body close to the Sun in
angular direction relative to the observer, the correction can be negligible because the
apparent location of the body will shift in tandem with the Sun.
"""
obstime = parse_time(time)
if observer is None:
body_icrs = get_body_barycentric(body, obstime)
else:
observer_icrs = SkyCoord(observer).icrs.cartesian
# This implementation is modeled after Astropy's `_get_apparent_body_position`
light_travel_time = 0. * u.s
emitted_time = obstime
delta_light_travel_time = 1. * u.s # placeholder value
while np.any(np.fabs(delta_light_travel_time) > 1.0e-8 * u.s):
body_icrs = get_body_barycentric(body, emitted_time)
distance = (body_icrs - observer_icrs).norm()
delta_light_travel_time = light_travel_time - distance / speed_of_light
light_travel_time = distance / speed_of_light
emitted_time = obstime - light_travel_time
if light_travel_time.isscalar:
ltt_string = f"{light_travel_time.to_value('s'):.2f}"
else:
ltt_string = f"{light_travel_time.to_value('s')}"
log.info(
f"Apparent body location accounts for {ltt_string} seconds of light travel time"
)
body_hgs = ICRS(body_icrs).transform_to(
HeliographicStonyhurst(obstime=obstime))
return body_hgs
def check_connection(url):
try:
resp = urlopen(urljoin(url, "/v2/getDataSources/"))
assert resp.getcode() == 200
assert isinstance(json.loads(resp.read()), dict)
return url
except Exception as e:
log.debug(f"Unable to connect to {url}:\n {e}")
log.info(f"Connection to {url} failed. Retrying with different url.")
return None
def get_body_heliographic_stonyhurst(body, time='now', observer=None):
"""
Return a `~sunpy.coordinates.frames.HeliographicStonyhurst` frame for the location of a
solar-system body at a specified time. The location can be corrected for light travel time
to an observer.
Parameters
----------
body : `str`
The solar-system body for which to calculate positions
time : various
Time to use as `~astropy.time.Time` or in a parse_time-compatible format
observer : `~astropy.coordinates.SkyCoord`
If None, the returned coordinate is the instantaneous or "true" location.
If not None, the returned coordinate is the astrometric location (i.e., accounts for light
travel time to the specified observer)
Returns
-------
out : `~sunpy.coordinates.frames.HeliographicStonyhurst`
Location of the solar-system body in the `~sunpy.coordinates.HeliographicStonyhurst` frame
Notes
-----
There is no correction for aberration due to observer motion. For a body close to the Sun in
angular direction relative to the observer, the correction can be negligible because the
apparent location of the body will shift in tandem with the Sun.
"""
obstime = parse_time(time)
if observer is None:
body_icrs = get_body_barycentric(body, obstime)
else:
observer_icrs = SkyCoord(observer).icrs.cartesian
# This implementation is modeled after Astropy's `_get_apparent_body_position`
light_travel_time = 0.*u.s
emitted_time = obstime
delta_light_travel_time = 1.*u.s # placeholder value
while np.any(np.fabs(delta_light_travel_time) > 1.0e-8*u.s):
body_icrs = get_body_barycentric(body, emitted_time)
distance = (body_icrs - observer_icrs).norm()
delta_light_travel_time = light_travel_time - distance / speed_of_light
light_travel_time = distance / speed_of_light
emitted_time = obstime - light_travel_time
log.info(f"Apparent body location accounts for {light_travel_time.to('s').value:.2f}"
" seconds of light travel time")
body_hgs = ICRS(body_icrs).transform_to(HGS(obstime=obstime))
return body_hgs
def get_body_heliographic_stonyhurst(body, time='now', observer=None):
"""
Return a `~sunpy.coordinates.frames.HeliographicStonyhurst` frame for the location of a
solar-system body at a specified time.
Parameters
----------
body : `str`
The solar-system body for which to calculate positions
time : various
Time to use as `~astropy.time.Time` or in a parse_time-compatible format
observer : `~astropy.coordinates.SkyCoord`
If not None, the returned coordinate is the apparent location (i.e., accounts for light
travel time)
Returns
-------
out : `~sunpy.coordinates.frames.HeliographicStonyhurst`
Location of the solar-system body in the `~sunpy.coordinates.HeliographicStonyhurst` frame
"""
obstime = parse_time(time)
if observer is None:
body_icrs = get_body_barycentric(body, obstime)
else:
observer_icrs = SkyCoord(observer).icrs.cartesian
# This implementation is modeled after Astropy's `_get_apparent_body_position`
light_travel_time = 0.*u.s
emitted_time = obstime
delta_light_travel_time = 1.*u.s # placeholder value
while np.any(np.fabs(delta_light_travel_time) > 1.0e-8*u.s):
body_icrs = get_body_barycentric(body, emitted_time)
distance = (body_icrs - observer_icrs).norm()
delta_light_travel_time = light_travel_time - distance / speed_of_light
light_travel_time = distance / speed_of_light
emitted_time = obstime - light_travel_time
log.info(f"Apparent body location accounts for {light_travel_time.to('s').value:.2f}"
" seconds of light travel time")
body_hgs = ICRS(body_icrs).transform_to(HGS(obstime=obstime))
return body_hgs
def get_request(self,
requests,
path=None,
overwrite=False,
progress=True,
downloader=None,
wait=True,
max_conn=default_max_conn,
**kwargs):
"""
Query JSOC to see if the request(s) is ready for download.
If the request is ready for download, it will then download it.
Parameters
----------
requests : `~drms.client.ExportRequest`, `str`, `list`
`~drms.client.ExportRequest` objects or `str` request IDs or lists
returned by `~sunpy.net.jsoc.jsoc.JSOCClient.request_data`.
path : `str`
Path to save data to, defaults to SunPy download dir.
progress : `bool`, optional
If `True` show a progress bar showing how many of the total files
have been downloaded. If `False`, no progress bar will be shown.
overwrite : `bool` or `str`, optional
Determine how to handle downloading if a file already exists with the
same name. If `False` the file download will be skipped and the path
returned to the existing file, if `True` the file will be downloaded
and the existing file will be overwritten, if ``'unique'`` the filename
will be modified to be unique.
downloader : `parfive.Downloader`, optional
The download manager to use.
wait : `bool`, optional
If `False` ``downloader.download()`` will not be called. Only has
any effect if ``downloader`` is not `None`.
Returns
-------
res: `parfive.Results`
A `parfive.Results` instance or `None` if no URLs to download
"""
c = drms.Client()
# Private communication from JSOC say we should not use more than one connection.
if kwargs.get('max_splits'):
log.info(f"max_splits keyword was passed and set to 1.")
kwargs['max_splits'] = 1
# Convert Responses to a list if not already
if isinstance(requests, str) or not isiterable(requests):
requests = [requests]
# Ensure all the requests are drms ExportRequest objects
for i, request in enumerate(requests):
if isinstance(request, str):
r = c.export_from_id(request)
requests[i] = r
# We only download if all are finished
if not all([r.has_succeeded() for r in requests]):
raise NotExportedError("Can not download as not all the requests "
"have been exported for download yet.")
# Ensure path has a {file} in it
if path is None:
default_dir = config.get("downloads", "download_dir")
path = os.path.join(default_dir, '{file}')
elif isinstance(path, Path):
path = str(path)
if isinstance(path, str) and '{file}' not in path:
path = os.path.join(path, '{file}')
paths = []
for request in requests:
if request.method == 'url-tar':
fname = path.format(file=Path(request.tarfile).name)
paths.append(os.path.expanduser(fname))
else:
for filename in request.data['filename']:
# Ensure we don't duplicate the file extension
ext = os.path.splitext(filename)[1]
if path.endswith(ext):
fname = path.strip(ext)
else:
fname = path
fname = fname.format(file=filename)
fname = os.path.expanduser(fname)
paths.append(fname)
dl_set = True
if not downloader:
dl_set = False
# Private communication from JSOC say we should not use more than one connection.
if max_conn != self.default_max_conn:
log.info(
f"Setting max parallel downloads to 1 for the JSOC client."
)
downloader = Downloader(progress=progress,
overwrite=overwrite,
max_conn=1)
urls = []
for request in requests:
if request.status == 0:
if request.protocol == 'as-is' or request.method == 'url-tar':
urls.extend(list(request.urls.url))
else:
for index, data in request.data.iterrows():
url_dir = request.request_url + '/'
urls.append(
urllib.parse.urljoin(url_dir, data['filename']))
if urls:
if progress:
print_message = "{0} URLs found for download. Full request totalling {1}MB"
print(print_message.format(len(urls), request._d['size']))
for aurl, fname in zip(urls, paths):
downloader.enqueue_file(aurl, filename=fname, **kwargs)
if dl_set and not wait:
return Results()
results = downloader.download()
return results
def test_origin():
with log.log_to_list() as log_list:
log.info('test1')
assert log_list[0].origin == 'sunpy.util.tests.test_logger'
assert log_list[0].message.startswith('test1')
def get_horizons_coord(body, time='now', id_type='majorbody'):
"""
Queries JPL HORIZONS and returns a `~astropy.coordinates.SkyCoord` for the location of a
solar-system body at a specified time. This location is the instantaneous or "true" location,
and is not corrected for light travel time or observer motion.
.. note::
This function requires the Astroquery package to be installed and
requires an Internet connection.
Parameters
----------
body : `str`
The solar-system body for which to calculate positions. One can also use the search form
linked below to find valid names or ID numbers.
id_type : `str`
If 'majorbody', search by name for planets, satellites, or other major bodies.
If 'smallbody', search by name for asteroids or comets.
If 'id', search by ID number.
time : {parse_time_types}
Time to use in a parse_time-compatible format
Returns
-------
`~astropy.coordinates.SkyCoord`
Location of the solar-system body
Notes
-----
Be aware that there can be discrepancies between the coordinates returned by JPL HORIZONS,
the coordinates reported in mission data files, and the coordinates returned by
`~sunpy.coordinates.get_body_heliographic_stonyhurst`.
References
----------
* `JPL HORIZONS <https://ssd.jpl.nasa.gov/?horizons>`_
* `JPL HORIZONS form to search bodies <https://ssd.jpl.nasa.gov/horizons.cgi?s_target=1#top>`_
* `Astroquery <https://astroquery.readthedocs.io/en/latest/>`_
Examples
--------
>>> from sunpy.coordinates import get_horizons_coord
Query the location of Venus
>>> get_horizons_coord('Venus barycenter', '2001-02-03 04:05:06') # doctest: +REMOTE_DATA
INFO: Obtained JPL HORIZONS location for Venus Barycenter (2) [sunpy.coordinates.ephemeris]
<SkyCoord (HeliographicStonyhurst: obstime=2001-02-03T04:05:06.000): (lon, lat, radius) in (deg, deg, AU)
(-33.93155836, -1.64998443, 0.71915147)>
Query the location of the SDO spacecraft
>>> get_horizons_coord('SDO', '2011-11-11 11:11:11') # doctest: +REMOTE_DATA
INFO: Obtained JPL HORIZONS location for Solar Dynamics Observatory (spac [sunpy.coordinates.ephemeris]
<SkyCoord (HeliographicStonyhurst: obstime=2011-11-11T11:11:11.000): (lon, lat, radius) in (deg, deg, AU)
(0.01019118, 3.29640728, 0.99011042)>
Query the location of the SOHO spacecraft via its ID number (-21)
>>> get_horizons_coord(-21, '2004-05-06 11:22:33', 'id') # doctest: +REMOTE_DATA
INFO: Obtained JPL HORIZONS location for SOHO (spacecraft) (-21) [sunpy.coordinates.ephemeris]
<SkyCoord (HeliographicStonyhurst: obstime=2004-05-06T11:22:33.000): (lon, lat, radius) in (deg, deg, AU)
(0.25234902, -3.55863633, 0.99923086)>
"""
obstime = parse_time(time)
array_time = np.reshape(obstime,
(-1, )) # Convert to an array, even if scalar
# Import here so that astroquery is not a module-level dependency
from astroquery.jplhorizons import Horizons
query = Horizons(
id=body,
id_type=id_type,
location='500@10', # Heliocentric (mean ecliptic)
epochs=array_time.tdb.jd.tolist()) # Time must be provided in JD TDB
try:
result = query.vectors()
except Exception: # Catch and re-raise all exceptions, and also provide query URL if generated
if query.uri is not None:
log.error(
f"See the raw output from the JPL HORIZONS query at {query.uri}"
)
raise
log.info(f"Obtained JPL HORIZONS location for {result[0]['targetname']}")
log.debug(f"See the raw output from the JPL HORIZONS query at {query.uri}")
# JPL HORIZONS results are sorted by observation time, so this sorting needs to be undone.
# Calling argsort() on an array returns the sequence of indices of the unsorted list to put the
# list in order. Calling argsort() again on the output of argsort() reverses the mapping:
# the output is the sequence of indices of the sorted list to put that list back in the
# original unsorted order.
unsorted_indices = obstime.argsort().argsort()
result = result[unsorted_indices]
vector = CartesianRepresentation(result['x'], result['y'], result['z'])
coord = SkyCoord(vector, frame=HeliocentricEclipticIAU76, obstime=obstime)
return coord.transform_to(HGS).reshape(obstime.shape)
def get_body_heliographic_stonyhurst(body, time='now', observer=None, *, include_velocity=False):
"""
Return a `~sunpy.coordinates.frames.HeliographicStonyhurst` frame for the location of a
solar-system body at a specified time. The location can be corrected for light travel time
to an observer.
Parameters
----------
body : `str`
The solar-system body for which to calculate positions
time : {parse_time_types}
Time to use in a parse_time-compatible format
observer : `~astropy.coordinates.SkyCoord`
If None, the returned coordinate is the instantaneous or "true" location.
If not None, the returned coordinate is the astrometric location (i.e., accounts for light
travel time to the specified observer)
Keyword Arguments
-----------------
include_velocity : `bool`
If True, include the body's velocity in the output coordinate. Defaults to False.
Returns
-------
out : `~sunpy.coordinates.frames.HeliographicStonyhurst`
Location of the solar-system body in the `~sunpy.coordinates.HeliographicStonyhurst` frame
Notes
-----
There is no correction for aberration due to observer motion. For a body close to the Sun in
angular direction relative to the observer, the correction can be negligible because the
apparent location of the body will shift in tandem with the Sun.
Examples
--------
>>> from sunpy.coordinates.ephemeris import get_body_heliographic_stonyhurst
Obtain the location of Venus
>>> get_body_heliographic_stonyhurst('venus', '2012-06-06 04:07:29')
<HeliographicStonyhurst Coordinate (obstime=2012-06-06T04:07:29.000, rsun=695700.0 km): (lon, lat, radius) in (deg, deg, AU)
(0.07349535, 0.05223575, 0.72605496)>
Obtain the location of Venus as seen from Earth when adjusted for light travel time
>>> earth = get_body_heliographic_stonyhurst('earth', '2012-06-06 04:07:29')
>>> get_body_heliographic_stonyhurst('venus', '2012-06-06 04:07:29', observer=earth)
INFO: Apparent body location accounts for 144.07 seconds of light travel time [sunpy.coordinates.ephemeris]
<HeliographicStonyhurst Coordinate (obstime=2012-06-06T04:07:29.000, rsun=695700.0 km): (lon, lat, radius) in (deg, deg, AU)
(0.07084926, 0.0520573, 0.72605477)>
Obtain the location and velocity of Mars
>>> mars = get_body_heliographic_stonyhurst('mars', '2001-02-03', include_velocity=True)
>>> mars
<HeliographicStonyhurst Coordinate (obstime=2001-02-03T00:00:00.000, rsun=695700.0 km): (lon, lat, radius) in (deg, deg, AU)
(63.03105777, -5.20656151, 1.6251161)
(d_lon, d_lat, d_radius) in (arcsec / s, arcsec / s, km / s)
(-0.02323686, 0.00073376, -1.4798387)>
Transform that same location and velocity of Mars to a different frame using
`~astropy.coordinates.SkyCoord`.
>>> from astropy.coordinates import SkyCoord
>>> from sunpy.coordinates import Helioprojective
>>> SkyCoord(mars).transform_to(Helioprojective(observer=earth))
<SkyCoord (Helioprojective: obstime=2001-02-03T00:00:00.000, rsun=695700.0 km, observer=<HeliographicStonyhurst Coordinate (obstime=2012-06-06T04:07:29.000, rsun=695700.0 km): (lon, lat, radius) in (deg, deg, AU)
(7.835757e-15, -0.00766698, 1.01475668)>): (Tx, Ty, distance) in (arcsec, arcsec, AU)
(-298029.94625805, -21753.50941181, 1.40010091)
(d_Tx, d_Ty, d_distance) in (arcsec / s, arcsec / s, km / s)
(-0.01652981, -0.00059216, -15.14320414)>
"""
obstime = parse_time(time)
if observer is None:
# If there is no observer, there is not adjustment for light travel time
emitted_time = obstime
else:
observer_icrs = SkyCoord(observer).icrs.cartesian
# This implementation is modeled after Astropy's `_get_apparent_body_position`
light_travel_time = 0.*u.s
emitted_time = obstime
delta_light_travel_time = 1.*u.s # placeholder value
while np.any(np.fabs(delta_light_travel_time) > 1.0e-8*u.s):
body_icrs = get_body_barycentric(body, emitted_time)
distance = (body_icrs - observer_icrs).norm()
delta_light_travel_time = light_travel_time - distance / speed_of_light
light_travel_time = distance / speed_of_light
emitted_time = obstime - light_travel_time
if light_travel_time.isscalar:
ltt_string = f"{light_travel_time.to_value('s'):.2f}"
else:
ltt_string = f"{light_travel_time.to_value('s')}"
log.info(f"Apparent body location accounts for {ltt_string} seconds of light travel time")
if include_velocity:
pos, vel = get_body_barycentric_posvel(body, emitted_time)
body_icrs = pos.with_differentials(vel.represent_as(CartesianDifferential))
else:
body_icrs = get_body_barycentric(body, emitted_time)
body_hgs = ICRS(body_icrs).transform_to(HeliographicStonyhurst(obstime=obstime))
return body_hgs
def get_horizons_coord(body, time='now', id_type='majorbody', *, include_velocity=False):
"""
Queries JPL HORIZONS and returns a `~astropy.coordinates.SkyCoord` for the location of a
solar-system body at a specified time. This location is the instantaneous or "true" location,
and is not corrected for light travel time or observer motion.
.. note::
This function requires the Astroquery package to be installed and
requires an Internet connection.
Parameters
----------
body : `str`
The solar-system body for which to calculate positions. One can also use the search form
linked below to find valid names or ID numbers.
id_type : `str`
If 'majorbody', search by name for planets, satellites, or other major bodies.
If 'smallbody', search by name for asteroids or comets.
If 'id', search by ID number.
time : {parse_time_types}, `dict`
Time to use in a parse_time-compatible format.
Alternatively, this can be a dictionary defining a range of times and
dates; the range dictionary has to be of the form
{{'start': start_time, 'stop': stop_time, 'step':’n[y|d|m|s]’}}.
``start_time`` and ``stop_time`` must be in a parse_time-compatible format,
and are interpreted as UTC time. ``step`` must be a string with either a
number and interval length (e.g. for every 10 seconds, ``'10s'``), or a
plain number for a number of evenly spaced intervals. For more information
see the docstring of `astroquery.jplhorizons.HorizonsClass`.
Keyword Arguments
-----------------
include_velocity : `bool`
If True, include the body's velocity in the output coordinate. Defaults to False.
Returns
-------
`~astropy.coordinates.SkyCoord`
Location of the solar-system body
Notes
-----
Be aware that there can be discrepancies between the coordinates returned by JPL HORIZONS,
the coordinates reported in mission data files, and the coordinates returned by
`~sunpy.coordinates.get_body_heliographic_stonyhurst`.
References
----------
* `JPL HORIZONS <https://ssd.jpl.nasa.gov/?horizons>`_
* `JPL HORIZONS form to search bodies <https://ssd.jpl.nasa.gov/horizons.cgi?s_target=1#top>`_
* `Astroquery <https://astroquery.readthedocs.io/en/latest/>`_
Examples
--------
>>> from sunpy.coordinates.ephemeris import get_horizons_coord
Query the location of Venus
>>> get_horizons_coord('Venus barycenter', '2001-02-03 04:05:06') # doctest: +REMOTE_DATA
INFO: Obtained JPL HORIZONS location for Venus Barycenter (2) [sunpy.coordinates.ephemeris]
<SkyCoord (HeliographicStonyhurst: obstime=2001-02-03T04:05:06.000, rsun=695700.0 km): (lon, lat, radius) in (deg, deg, AU)
(-33.93155836, -1.64998443, 0.71915147)>
Query the location of the SDO spacecraft
>>> get_horizons_coord('SDO', '2011-11-11 11:11:11') # doctest: +REMOTE_DATA
INFO: Obtained JPL HORIZONS location for Solar Dynamics Observatory (spac [sunpy.coordinates.ephemeris]
<SkyCoord (HeliographicStonyhurst: obstime=2011-11-11T11:11:11.000, rsun=695700.0 km): (lon, lat, radius) in (deg, deg, AU)
(0.01019118, 3.29640728, 0.99011042)>
Query the location of the SOHO spacecraft via its ID number (-21)
>>> get_horizons_coord(-21, '2004-05-06 11:22:33', 'id') # doctest: +REMOTE_DATA
INFO: Obtained JPL HORIZONS location for SOHO (spacecraft) (-21) [sunpy.coordinates.ephemeris]
<SkyCoord (HeliographicStonyhurst: obstime=2004-05-06T11:22:33.000, rsun=695700.0 km): (lon, lat, radius) in (deg, deg, AU)
(0.25234902, -3.55863633, 0.99923086)>
Query the location and velocity of the asteroid Juno
>>> get_horizons_coord('Juno', '1995-07-18 07:17', 'smallbody', include_velocity=True) # doctest: +REMOTE_DATA
INFO: Obtained JPL HORIZONS location for 3 Juno (A804 RA) [sunpy.coordinates.ephemeris]
<SkyCoord (HeliographicStonyhurst: obstime=1995-07-18T07:17:00.000, rsun=695700.0 km): (lon, lat, radius) in (deg, deg, AU)
(-25.16107532, 14.59098438, 3.17667664)
(d_lon, d_lat, d_radius) in (arcsec / s, arcsec / s, km / s)
(-0.03306548, 0.00052415, -2.66709222)>
Query the location of Solar Orbiter at a set of 12 regularly sampled times
>>> get_horizons_coord('Solar Orbiter',
... time={{'start': '2020-12-01',
... 'stop': '2020-12-02',
... 'step': '12'}}) # doctest: +REMOTE_DATA
INFO: Obtained JPL HORIZONS location for Solar Orbiter (spacecraft) (-144 [sunpy.coordinates.ephemeris]
...
"""
if isinstance(time, dict):
if set(time.keys()) != set(['start', 'stop', 'step']):
raise ValueError('time dictionary must have the keys ["start", "stop", "step"]')
epochs = time
jpl_fmt = '%Y-%m-%d %H:%M:%S'
epochs['start'] = parse_time(epochs['start']).tdb.strftime(jpl_fmt)
epochs['stop'] = parse_time(epochs['stop']).tdb.strftime(jpl_fmt)
else:
obstime = parse_time(time)
array_time = np.reshape(obstime, (-1,)) # Convert to an array, even if scalar
epochs = array_time.tdb.jd.tolist() # Time must be provided in JD TDB
# Import here so that astroquery is not a module-level dependency
from astroquery.jplhorizons import Horizons
query = Horizons(id=body, id_type=id_type,
location='500@10', # Heliocentric (mean ecliptic)
epochs=epochs)
try:
result = query.vectors()
except Exception as e: # Catch and re-raise all exceptions, and also provide query URL if generated
if query.uri is not None:
log.error(f"See the raw output from the JPL HORIZONS query at {query.uri}")
raise e
finally:
query._session.close()
log.info(f"Obtained JPL HORIZONS location for {result[0]['targetname']}")
log.debug(f"See the raw output from the JPL HORIZONS query at {query.uri}")
if isinstance(time, dict):
obstime = parse_time(result['datetime_jd'], format='jd', scale='tdb')
else:
# JPL HORIZONS results are sorted by observation time, so this sorting needs to be undone.
# Calling argsort() on an array returns the sequence of indices of the unsorted list to put the
# list in order. Calling argsort() again on the output of argsort() reverses the mapping:
# the output is the sequence of indices of the sorted list to put that list back in the
# original unsorted order.
unsorted_indices = obstime.argsort().argsort()
result = result[unsorted_indices]
vector = CartesianRepresentation(result['x'], result['y'], result['z'])
if include_velocity:
velocity = CartesianDifferential(result['vx'], result['vy'], result['vz'])
vector = vector.with_differentials(velocity)
coord = SkyCoord(vector, frame=HeliocentricEclipticIAU76, obstime=obstime)
return coord.transform_to(HeliographicStonyhurst).reshape(obstime.shape)
def download_sample_data(overwrite=False):
"""
Download all sample data at once. This will overwrite any existing files.
Parameters
----------
overwrite: `bool`
Overwrite existing sample data.
"""
# Workaround for tox only. This is not supported as a user option
sampledata_dir = os.environ.get("SUNPY_SAMPLEDIR", False)
if sampledata_dir:
sampledata_dir = Path(sampledata_dir).expanduser().resolve()
_is_writable_dir(sampledata_dir)
else:
# Creating the directory for sample files to be downloaded
sampledata_dir = Path(get_and_create_sample_dir())
dl = Downloader(overwrite=overwrite)
first_url = _base_urls[0]
already_downloaded = []
for file_name in _sample_files.keys():
url = urljoin(first_url, file_name)
fname = sampledata_dir / file_name
# We have to avoid calling download if we already have all the files.
if fname.exists() and not overwrite:
already_downloaded.append(fname)
else:
dl.enqueue_file(url, filename=fname)
if dl.queued_downloads:
results = dl.download()
else:
return already_downloaded
if not results.errors:
return results
else:
log.info(
'Failed to download one or more sample data files, retrying with a mirror.'
)
for retry_url in _base_urls[1:]:
for i, err in enumerate(results.errors):
file_name = err.filepath_partial().name
log.debug(
f"Failed to download {_sample_files[file_name]} from {err.url}: {err.exception}"
)
# Overwrite the parfive error to change the url to a mirror
new_url = urljoin(retry_url, file_name)
results._errors[i] = _error(err.filepath_partial, new_url,
err.exception)
results = dl.retry(results)
if not results.errors:
return results
for err in results.errors:
file_name = err.filepath_partial().name
log.debug(
f"Failed to download {_sample_files[file_name]} from {err.url}: {err.exception}"
)
log.error(
f"Failed to download {_sample_files[file_name]} from all mirrors, the file will not be available."
)
return results
def test_origin():
with log.log_to_list() as log_list:
log.info('test1')
assert log_list[0].origin == 'sunpy.util.tests.test_logger'
assert log_list[0].message.startswith('test1')
def get_horizons_coord(body, time='now', id_type='majorbody'):
"""
Queries JPL HORIZONS and returns a `~astropy.coordinates.SkyCoord` for the location of a
solar-system body at a specified time. This location is the instantaneous or "true" location,
and is not corrected for light travel time or observer motion. This function requires the
Astroquery package to be installed and requires an Internet connection.
Parameters
----------
body : `str`
The solar-system body for which to calculate positions
id_type : `str`
If 'majorbody', search by name for planets or satellites. If 'id', search by ID number.
time : various
Time to use as `~astropy.time.Time` or in a parse_time-compatible format
Returns
-------
`~astropy.coordinates.SkyCoord`
Location of the solar-system body
Notes
-----
Be aware that there can be discrepancies between the coordinates returned by JPL HORIZONS,
the coordinates reported in mission data files, and the coordinates returned by
`~sunpy.coordinates.get_body_heliographic_stonyhurst`.
References
----------
* `JPL HORIZONS <https://ssd.jpl.nasa.gov/?horizons>`_
* `Astroquery <https://astroquery.readthedocs.io/en/latest/>`_
Examples
--------
.. Run these tests with a temp cache dir
.. testsetup::
>>> from astropy.config.paths import set_temp_cache
>>> import tempfile
>>> c = set_temp_cache(tempfile.mkdtemp())
>>> _ = c.__enter__()
>>> from sunpy.coordinates import get_horizons_coord
Query the location of Venus
>>> get_horizons_coord('Venus barycenter', '2001-02-03 04:05:06') # doctest: +REMOTE_DATA
INFO: Obtained JPL HORIZONS location for Venus Barycenter (2) [sunpy.coordinates.ephemeris]
<SkyCoord (HeliographicStonyhurst: obstime=2001-02-03T04:05:06.000): (lon, lat, radius) in (deg, deg, AU)
(326.06844114, -1.64998481, 0.71915147)>
Query the location of the SDO spacecraft
>>> get_horizons_coord('SDO', '2011-11-11 11:11:11') # doctest: +REMOTE_DATA
INFO: Obtained JPL HORIZONS location for Solar Dynamics Observatory (spac [sunpy.coordinates.ephemeris]
<SkyCoord (HeliographicStonyhurst: obstime=2011-11-11T11:11:11.000): (lon, lat, radius) in (deg, deg, AU)
(0.01018888, 3.29640407, 0.99011042)>
Query the location of the SOHO spacecraft via its ID number (-21)
>>> get_horizons_coord(-21, '2004-05-06 11:22:33', 'id') # doctest: +REMOTE_DATA
INFO: Obtained JPL HORIZONS location for SOHO (spacecraft) (-21) [sunpy.coordinates.ephemeris]
<SkyCoord (HeliographicStonyhurst: obstime=2004-05-06T11:22:33.000): (lon, lat, radius) in (deg, deg, AU)
(0.2523461, -3.55863351, 0.99923086)>
.. testcleanup::
>>> _ = c.__exit__()
"""
obstime = parse_time(time)
# Import here so that astroquery is not a module-level dependency
from astroquery.jplhorizons import Horizons
query = Horizons(id=body, id_type=id_type,
location='500@10', # Heliocentric (mean ecliptic)
epochs=obstime.tdb.jd) # Time must be provided in JD TDB
try:
result = query.vectors()
except Exception: # Catch and re-raise all exceptions, and also provide query URL if generated
if query.uri is not None:
log.error(f"See the raw output from the JPL HORIZONS query at {query.uri}")
raise
log.info(f"Obtained JPL HORIZONS location for {result[0]['targetname']}")
vector = CartesianRepresentation(result[0]['x', 'y', 'z'])*u.AU
coord = SkyCoord(vector, frame=HeliocentricMeanEcliptic, obstime=obstime)
return coord.transform_to(HGS)
