def test_kernel_download(self, kernel):
if 'TRAVIS' in os.environ:
for url in spice.kernel_dict[kernel].urls:
if url[:3] == 'ftp':
pytest.skip("FTP doesn't work on travis")
with pytest.warns(None) as record:
spice.get_kernel(kernel)
assert len(record) == 0
def test_kernel_download(kernel):
if 'TRAVIS' in os.environ:
for url in spice.kernel_dict[kernel].urls:
if url[:3] == 'ftp':
pytest.skip("FTP doesn't work on travis")
if 'AZURE' in os.environ and 'psp' in kernel:
pytest.skip("PSP kernels don't work on Azure")
with pytest.warns(None) as record:
spice.get_kernel(kernel)
assert len(record) == 0
def extractSolOrbit(self):
"""
Get the SPICE orbit data for SolO and put into coordsCarrington
"""
import heliopy.data.spice as spicedata
import heliopy.spice as spice
spicedata.get_kernel("solo")
solo = spice.Trajectory("Solar Orbiter")
times = list(self.df.index.to_pydatetime())
solo.generate_positions(times, 'Sun', 'IAU_SUN') # Is in KM
self.coordsCarrington = solo.coords.transform_to(
frame=frames.HeliographicCarrington)
def get_sc_lonlat_test(kernel, scname, frame, starttime, endtime, res_in_days):
'''
make spacecraft positions
kernel,scname,frame,starttime, endtime,res_in_days
'psp_pred','SPP','HEEQ',datetime(2018, 8,13),'datetime(2024, 8,13), 1
kernels: psp_pred, stereoa_pred,
frames: ECLIPJ2000 HEE HEEQ, HCI
frames https://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/req/frames.html Appendix. ``Built in'' Inertial Reference Frames
'''
spice.furnish(spicedata.get_kernel(kernel))
sc = spice.Trajectory(scname)
sc_time = []
while starttime < endtime:
sc_time.append(starttime)
starttime += timedelta(days=res_in_days)
sc_time_num = mdates.date2num(sc_time)
sc.generate_positions(sc_time, 'Sun', frame)
sc.change_units(astropy.units.AU)
sc_r, sc_lat, sc_lon = cart2sphere(sc.x, sc.y, sc.z)
screc = np.rec.array([sc_time_num, sc_r, sc_lon, sc_lat, sc.x, sc.y, sc.z],
dtype=[('time', 'f8'), ('r', 'f8'), ('lon', 'f8'),
('lat', 'f8'), ('x', 'f8'), ('y', 'f8'),
('z', 'f8')])
return screc
def _setup_spice():
'''
Method to download some common files that spice needs to do orbit
calculations.
'''
for kernel in ['lsk', 'planet_trajectories']:
loc = dataspice.get_kernel(kernel)
spiceypy.furnsh(loc)
def _setup_spice():
'''
Method to download some common files that spice needs to do orbit
calculations.
'''
for kernel in dataspice.generic_kernels:
loc = dataspice.get_kernel(kernel.short_name)
spiceypy.furnsh(loc)
def load(self, body_name):
if body_name not in self.loaded_kernels:
if not self.setup_has_been_run:
spice.setup_spice()
self.setup_has_been_run = True
if body_name == 'psp':
kernels = spicedata.get_kernel('psp')
kernels += spicedata.get_kernel('psp_pred')
spice.furnish(kernels)
self.loaded_kernels.append(body_name)
if body_name == 'stereo_a':
kernels = spicedata.get_kernel('stereo_a')
kernels += spicedata.get_kernel('stereo_a_pred')
spice.furnish(kernels)
self.loaded_kernels.append(body_name)
if body_name == 'stereo_b':
kernels = spicedata.get_kernel('stereo_b')
kernels += spicedata.get_kernel('stereo_b_pred')
spice.furnish(kernels)
self.loaded_kernels.append(body_name)
if body_name == 'soho':
kernels = spicedata.get_kernel('soho')
spice.furnish(kernels)
self.loaded_kernels.append(body_name)
def test_kernel():
kernel = spicedata.get_kernel('helios1')[0]
solo = spice.Body('helios 1')
assert len(kernel.bodies) == 1
assert kernel.bodies[0] == solo
assert kernel.coverage(solo) == [
datetime.datetime(1974, 12, 10, 23, 50, 1, 662,
tzinfo=datetime.timezone.utc),
datetime.datetime(1981, 9, 30, 1, 29, 54, 1651,
tzinfo=datetime.timezone.utc)
]
def kernel_loader(spacecraft: Union[int, str] = 2) -> spice.Trajectory:
"""
:param spacecraft: 1 or 2 for Helios 1 or 2, can also be 'ulysses'
:return: unfurnished orbiter
"""
if spacecraft == 1 or spacecraft == 2:
if spacecraft == 1:
orbiter_kernel = spice_data.get_kernel('helios1_rec')
else:
orbiter_kernel = spice_data.get_kernel('helios2')
spice.furnish(orbiter_kernel)
orbiter = spice.Trajectory('Helios ' + str(spacecraft))
# elif spacecraft == 'ulysses':
# orbiter_kernel = spice_data.get_kernel(str(spacecraft))
# spice.furnish(orbiter_kernel)
# orbiter = spice.Trajectory(spacecraft)
else:
raise NotImplementedError('The only probes that can be imported are Helios 1 , Helios 2 and Ulysses')
return orbiter
def test_spice():
orbiter_kernel = spicedata.get_kernel('solo_2020')
spice.furnish(orbiter_kernel)
orbiter = spice.Trajectory('Solar Orbiter')
# Generate 1000 days of data
starttime = datetime(2020, 3, 1)
times = [starttime + n * timedelta(days=1) for n in range(1000)]
orbiter.generate_positions(times, 'Sun', 'ECLIPJ2000')
assert orbiter.times == times
# Check it works with numpy arrays too
times = np.array(times)
orbiter.generate_positions(times, 'Sun', 'ECLIPJ2000')
def test_kernel_download(kernel):
if 'TRAVIS' in os.environ:
for url in spicedata.kernel_dict[kernel].urls:
if url[:3] == 'ftp':
pytest.skip("FTP doesn't work on travis")
if 'AZURE' in os.environ and 'psp' in kernel:
pytest.skip("PSP kernels don't work on Azure")
# Test download
with pytest.warns(None) as record:
kernel = spicedata.get_kernel(kernel)[0]
assert len(record) == 0
# Check that kernel is valid
if isinstance(kernel, spice.SPKKernel):
kernel.bodies
def get_planet_orbit(planet: str, start_date: str = '20/01/1976', end_date: str = '01/10/1979',
interval: float = 1) -> spice.Trajectory:
"""
Finds the orbiter for a given planet
:param planet: planet that we want to analyse
:param start_date: start date of analysis
:param end_date: end date of analysis
:param interval: interval between each date in the orbiter, defaults to 1
:return: orbiter of the planet
"""
orbiter_kernel = spice_data.get_kernel('planet_trajectories')
spice.furnish(orbiter_kernel)
orbiter = spice.Trajectory(planet)
start_time = datetime.strptime(start_date, '%d/%m/%Y')
end_time = datetime.strptime(end_date, '%d/%m/%Y')
times = []
while start_time < end_time:
times.append(start_time)
start_time = start_time + timedelta(days=interval)
orbiter.generate_positions(times, 'Sun', 'ECLIPJ2000')
orbiter.change_units(u.au)
return orbiter
def test_kernel():
kernel = spicedata.get_kernel('solo')[0]
solo = spice.Body('solar orbiter')
assert len(kernel.bodies) == 1
assert kernel.bodies[0] == solo
assert kernel.coverage(solo) == [
datetime.datetime(2020,
2,
10,
4,
55,
49,
670002,
tzinfo=datetime.timezone.utc),
datetime.datetime(2030,
11,
20,
10,
54,
51,
644258,
tzinfo=datetime.timezone.utc)
]
def solo_trajectory():
orbiter_kernel = spicedata.get_kernel('solo')
spice.furnish(orbiter_kernel)
return spice.Trajectory('Solar Orbiter')
# ---
# - Working with SPICE kernels
# - Built-in support for:
# - Helios, Juno, **PSP**, **Solar Orbiter**, STEREO, Ulysses
# - Can work with custom SPICE kernels
# ``heliopy.spice`` example
# ---
# In[5]:
from heliopy import spice
import heliopy.data.spice as spicedata
# Download and load Solar Orbiter predicted SPICE kernel
spice.furnish(spicedata.get_kernel('solo_2020'))
solo = spice.Trajectory('Solar Orbiter')
# Specify times at which to sample the trajectory
from datetime import datetime, timedelta
starttime = datetime(2020, 2, 20)
times = [starttime + timedelta(days=i) for i in range(365)]
# Generate the trajectory
solo.generate_positions(times, 'Sun', 'ECLIPJ2000')
# Print first 3 positions
print('Positions:', solo.x[:3], solo.y[:3], solo.z[:3], sep='\n')
# In[6]:
In this example we download the Solar Orbiter SPICE kernel, and plot it's orbit
from 2020 to 2028.
"""
import heliopy.data.spice as spicedata
import heliopy.spice as spice
from datetime import datetime, timedelta
import astropy.units as u
import numpy as np
###############################################################################
# Load the solar orbiter spice kernel. HelioPy will automatically fetch the
# latest kernel
orbiter_kernel = spicedata.get_kernel('solo_2020')
spice.furnish(orbiter_kernel)
orbiter = spice.Trajectory('Solar Orbiter')
###############################################################################
# Generate a time for every day between starttime and endtime
starttime = datetime(2020, 3, 1)
endtime = datetime(2028, 1, 1)
times = []
while starttime < endtime:
times.append(starttime)
starttime += timedelta(days=1)
###############################################################################
# Generate positions
orbiter.generate_positions(times, 'Sun', 'ECLIPJ2000')
def make_positions():
########################################## PSP
starttime =datetime(2018, 8,13)
endtime = datetime(2025, 8, 31)
psp_time = []
while starttime < endtime:
psp_time.append(starttime)
starttime += timedelta(days=res_in_days)
psp_time_num=mdates.date2num(psp_time)
spice.furnish(spicedata.get_kernel('psp_pred'))
psp=spice.Trajectory('SPP')
psp.generate_positions(psp_time,'Sun',frame)
print('PSP pos')
psp.change_units(astropy.units.AU)
[psp_r, psp_lat, psp_lon]=cart2sphere(psp.x,psp.y,psp.z)
print('PSP conv')
############################################## BepiColombo
starttime =datetime(2018, 10, 21)
endtime = datetime(2025, 11, 2)
bepi_time = []
while starttime < endtime:
bepi_time.append(starttime)
starttime += timedelta(days=res_in_days)
bepi_time_num=mdates.date2num(bepi_time)
spice.furnish(spicedata.get_kernel('bepi_pred'))
bepi=spice.Trajectory('BEPICOLOMBO MPO') # or BEPICOLOMBO MMO
bepi.generate_positions(bepi_time,'Sun',frame)
bepi.change_units(astropy.units.AU)
[bepi_r, bepi_lat, bepi_lon]=cart2sphere(bepi.x,bepi.y,bepi.z)
print('Bepi')
#################################################### Solar Orbiter
starttime = datetime(2020, 3, 1)
endtime = datetime(2026, 1, 1)
solo_time = []
while starttime < endtime:
solo_time.append(starttime)
starttime += timedelta(days=res_in_days)
solo_time_num=mdates.date2num(solo_time)
spice.furnish(spicedata.get_kernel('solo_2020'))
solo=spice.Trajectory('Solar Orbiter')
solo.generate_positions(solo_time, 'Sun',frame)
solo.change_units(astropy.units.AU)
[solo_r, solo_lat, solo_lon]=cart2sphere(solo.x,solo.y,solo.z)
print('Solo')
plt.figure(1, figsize=(12,9))
plt.plot_date(psp_time,psp_r,'-', label='R')
plt.plot_date(psp_time,psp_lat,'-',label='lat')
plt.plot_date(psp_time,psp_lon,'-',label='lon')
plt.ylabel('AU / RAD')
plt.legend()
plt.figure(2, figsize=(12,9))
plt.plot_date(bepi_time,bepi_r,'-', label='R')
plt.plot_date(bepi_time,bepi_lat,'-',label='lat')
plt.plot_date(bepi_time,bepi_lon,'-',label='lon')
plt.title('Bepi Colombo position '+frame)
plt.ylabel('AU / RAD')
plt.legend()
plt.figure(3, figsize=(12,9))
plt.plot_date(solo_time,solo_r,'-', label='R')
plt.plot_date(solo_time,solo_lat,'-',label='lat')
plt.plot_date(solo_time,solo_lon,'-',label='lon')
plt.title('Solar Orbiter position '+frame)
plt.ylabel('AU / RAD')
plt.legend()
########### plots
######## R with all three
plt.figure(4, figsize=(16,10))
plt.plot_date(psp_time,psp.r,'-',label='PSP')
plt.plot_date(bepi_time,bepi.r,'-',label='Bepi Colombo')
plt.plot_date(solo_time,solo.r,'-',label='Solar Orbiter')
plt.legend()
plt.title('Heliocentric distance of heliospheric observatories')
plt.ylabel('AU')
plt.savefig('results/positions_plots/bepi_psp_solo_R.png')
##### Longitude all three
plt.figure(5, figsize=(16,10))
plt.plot_date(psp_time,psp_lon*180/np.pi,'-',label='PSP')
plt.plot_date(bepi_time,bepi_lon*180/np.pi,'-',label='Bepi Colombo')
plt.plot_date(solo_time,solo_lon*180/np.pi,'-',label='Solar Orbiter')
plt.legend()
plt.title(frame+' longitude')
plt.ylabel('DEG')
plt.savefig('results/positions_plots/bepi_psp_solo_longitude_'+frame+'.png')
############# Earth for mercury, venusus, STA
#https://docs.heliopy.org/en/stable/data/spice.html
planet_kernel=spicedata.get_kernel('planet_trajectories')
starttime =datetime(2018, 1, 1)
endtime = datetime(2028, 12, 31)
earth_time = []
while starttime < endtime:
earth_time.append(starttime)
starttime += timedelta(days=res_in_days)
earth_time_num=mdates.date2num(earth_time)
earth=spice.Trajectory('399') #399 for Earth, not barycenter (because of moon)
earth.generate_positions(earth_time,'Sun',frame)
earth.change_units(astropy.units.AU)
[earth_r, earth_lat, earth_lon]=cart2sphere(earth.x,earth.y,earth.z)
print('Earth')
################ mercury
mercury_time_num=earth_time_num
mercury=spice.Trajectory('1') #barycenter
mercury.generate_positions(earth_time,'Sun',frame)
mercury.change_units(astropy.units.AU)
[mercury_r, mercury_lat, mercury_lon]=cart2sphere(mercury.x,mercury.y,mercury.z)
print('mercury')
################# venus
venus_time_num=earth_time_num
venus=spice.Trajectory('2')
venus.generate_positions(earth_time,'Sun',frame)
venus.change_units(astropy.units.AU)
[venus_r, venus_lat, venus_lon]=cart2sphere(venus.x,venus.y,venus.z)
print('venus')
############### Mars
mars_time_num=earth_time_num
mars=spice.Trajectory('4')
mars.generate_positions(earth_time,'Sun',frame)
mars.change_units(astropy.units.AU)
[mars_r, mars_lat, mars_lon]=cart2sphere(mars.x,mars.y,mars.z)
print('mars')
#############stereo-A
sta_time_num=earth_time_num
spice.furnish(spicedata.get_kernel('stereo_a_pred'))
sta=spice.Trajectory('-234')
sta.generate_positions(earth_time,'Sun',frame)
sta.change_units(astropy.units.AU)
[sta_r, sta_lat, sta_lon]=cart2sphere(sta.x,sta.y,sta.z)
print('STEREO-A')
#save positions
if high_res_mode:
pickle.dump([psp_time,psp_time_num,psp_r,psp_lon,psp_lat,bepi_time,bepi_time_num,bepi_r,bepi_lon,bepi_lat,solo_time,solo_time_num,solo_r,solo_lon,solo_lat], open( 'positions_plots/psp_solo_bepi_'+frame+'_1min.p', "wb" ) )
sys.exit()
else:
psp=np.rec.array([psp_time_num,psp_r,psp_lon,psp_lat, psp.x, psp.y,psp.z],dtype=[('time','f8'),('r','f8'),('lon','f8'),('lat','f8'),('x','f8'),('y','f8'),('z','f8')])
bepi=np.rec.array([bepi_time_num,bepi_r,bepi_lon,bepi_lat,bepi.x, bepi.y,bepi.z],dtype=[('time','f8'),('r','f8'),('lon','f8'),('lat','f8'),('x','f8'),('y','f8'),('z','f8')])
solo=np.rec.array([solo_time_num,solo_r,solo_lon,solo_lat,solo.x, solo.y,solo.z],dtype=[('time','f8'),('r','f8'),('lon','f8'),('lat','f8'),('x','f8'),('y','f8'),('z','f8')])
sta=np.rec.array([sta_time_num,sta_r,sta_lon,sta_lat,sta.x, sta.y,sta.z],dtype=[('time','f8'),('r','f8'),('lon','f8'),('lat','f8'),('x','f8'),('y','f8'),('z','f8')])
earth=np.rec.array([earth_time_num,earth_r,earth_lon,earth_lat, earth.x, earth.y,earth.z],dtype=[('time','f8'),('r','f8'),('lon','f8'),('lat','f8'),('x','f8'),('y','f8'),('z','f8')])
venus=np.rec.array([venus_time_num,venus_r,venus_lon,venus_lat, venus.x, venus.y,venus.z],dtype=[('time','f8'),('r','f8'),('lon','f8'),('lat','f8'),('x','f8'),('y','f8'),('z','f8')])
mars=np.rec.array([mars_time_num,mars_r,mars_lon,mars_lat, mars.x, mars.y,mars.z],dtype=[('time','f8'),('r','f8'),('lon','f8'),('lat','f8'),('x','f8'),('y','f8'),('z','f8')])
mercury=np.rec.array([mercury_time_num,mercury_r,mercury_lon,mercury_lat,mercury.x, mercury.y,mercury.z],dtype=[('time','f8'),('r','f8'),('lon','f8'),('lat','f8'),('x','f8'),('y','f8'),('z','f8')])
pickle.dump([psp, bepi, solo, sta, earth, venus, mars, mercury,frame], open( 'results/positions_psp_solo_bepi_sta_planets_'+frame+'_2hours.p', "wb" ) )
#load with [psp, bepi, solo, sta, earth, venus, mars, mercury,frame]=pickle.load( open( 'positions_psp_solo_bepi_sta_planets_HCI_6hours_2018_2025.p', "rb" ) )
end=time.time()
print( 'generate position took time in seconds:', round((end-start),1) )
In this example we download the Parker Solar Probe SPICE kernel, and plot
its orbit for the first year.
"""
import heliopy.data.spice as spicedata
import heliopy.spice as spice
from datetime import datetime, timedelta
import astropy.units as u
import numpy as np
###############################################################################
# Load the solar orbiter spice kernel. heliopy will automatically fetch and
# load the latest kernel
spicedata.get_kernel('psp')
spicedata.get_kernel('psp_pred')
psp = spice.Trajectory('SPP')
###############################################################################
# Generate a time for every day between starttime and endtime
starttime = datetime(2018, 8, 14)
endtime = starttime + timedelta(days=365)
times = []
while starttime < endtime:
times.append(starttime)
starttime += timedelta(hours=6)
###############################################################################
# Generate positions
psp.generate_positions(times, 'Sun', 'ECLIPJ2000')
How to plot orbits from SPICE kernels.
In this example we download the Solar Orbiter SPICE kernel, and plot it's orbit
from 2020 to 2028.
"""
import heliopy.data.spice as spicedata
import heliopy.spice as spice
from datetime import datetime, timedelta
import astropy.units as u
import numpy as np
###############################################################################
# Load the solar orbiter spice kernel. HelioPy will automatically fetch the
# latest kernel
orbiter_kernel = spicedata.get_kernel('solar orbiter 2020')
spice.furnish(orbiter_kernel)
orbiter = spice.Trajectory('Solar Orbiter')
###############################################################################
# Generate a time for every day between starttime and endtime
starttime = datetime(2020, 3, 1)
endtime = datetime(2028, 1, 1)
times = []
while starttime < endtime:
times.append(starttime)
starttime += timedelta(days=1)
###############################################################################
# Generate positions
orbiter.generate_positions(times, 'Sun', 'ECLIPJ2000')
#print( 'generate test position took time in seconds:', (end-start) )
#sys.exit()
########################################## MAKE TRAJECTORIES ############################
########################################## PSP
starttime = datetime(2018, 8, 13)
endtime = datetime(2025, 8, 31)
psp_time = []
while starttime < endtime:
psp_time.append(starttime)
starttime += timedelta(days=res_in_days)
psp_time_num = mdates.date2num(psp_time)
spice.furnish(spicedata.get_kernel('psp_pred'))
psp = spice.Trajectory('SPP')
psp.generate_positions(psp_time, 'Sun', frame)
print('PSP pos')
psp.change_units(astropy.units.AU)
[psp_r, psp_lat, psp_lon] = cart2sphere(psp.x, psp.y, psp.z)
print('PSP conv')
############################################## BepiColombo
starttime = datetime(2018, 10, 21)
endtime = datetime(2025, 11, 2)
bepi_time = []
while starttime < endtime:
bepi_time.append(starttime)
def solo_trajectory():
orbiter_kernel = spicedata.get_kernel('helios1')
spice.furnish(orbiter_kernel)
return spice.Trajectory('Helios 1')
"""
Overview
--------
`SPICE`_ is a NASA toolkit for calculating the position of bodies
(including planets and spacecraft) within the solar system. This module builds
on the `spiceypy`_ package to provide a high level interface to the SPICE
toolkit for performing orbital calculations using spice kernels.
Integration with :mod:`astropy.coordinates`
-------------------------------------------
As well as allowing positions to be calculated in any coordinate system defined
in the `SPICE`_ toolkit, :mod:`heliopy.spice` can also construct
:class:`astropy.coordinates.SkyCoord` objects if the frame is implemented in
astropy or SunPy. See the documentaiton of
:meth:`heliopy.spice.Trajectory.coords()` for information on which frames are
supported.
.. _SPICE: https://naif.jpl.nasa.gov/naif/toolkit.html
.. _spiceypy: https://spiceypy.readthedocs.io/en/master/
"""
import heliopy.data.spice as dataspice
from .spice import *
for kernel in dataspice.generic_kernels:
k = dataspice.get_kernel(kernel.short_name)
furnish(k)
# ---
# - Working with SPICE kernels
# - Built-in support for:
# - Helios, Juno, **PSP**, **Solar Orbiter**, STEREO, Ulysses
# - Can work with custom SPICE kernels
# ``heliopy.spice`` example
# ---
# In[11]:
from heliopy import spice
import heliopy.data.spice as spicedata
# Download and load Solar Orbiter predicted SPICE kernel
spice.furnish(spicedata.get_kernel('solo_2020'))
solo = spice.Trajectory('Solar Orbiter')
# In[12]:
# Specify times at which to sample the trajectory
from datetime import datetime, timedelta
starttime = datetime(2020, 2, 20)
times = [starttime + timedelta(days=i) for i in range(365)]
# Generate the trajectory
solo.generate_positions(times, 'Sun', 'ECLIPJ2000')
# Print first 3 positions
print('Positions:', solo.x[:3], solo.y[:3], solo.z[:3], sep='\n')
def test_built_in(self):
for kernel in spice.available_kernels:
spice.get_kernel(kernel)
import astropy.units as u
import astropy.constants as const
import astropy.coordinates as coord
import sunpy.coordinates.frames as frames
import heliopy.data.spice as spicedata
from heliopy import spice
for kernel in [
'psp', 'planet_trajectories', 'planet_orientations', 'psp_pred', 'solo'
]:
k = spicedata.get_kernel(kernel)
spice.furnish(k)
def loc(dtime, body):
traj = spice.Trajectory(body)
traj.generate_positions([dtime], 'Sun', 'IAU_SUN')
traj_coord = traj.coords
traj_coord.representation_type = 'spherical'
return traj_coord
def spiral_correction(psp_coord, vsw):
omega_sun = 14.713 * u.deg / u.d
def delta_long(r):
return omega_sun * (r - 2.5 * const.R_sun) / vsw
psp_solar_lon = psp_coord.lon + delta_long(psp_coord.radius)
psp_solar_surface = coord.SkyCoord(radius=2.49 * const.R_sun,
lat=psp_coord.lat,
def test_built_in(self):
for kernel in spice.kernel_dict:
spice.get_kernel(kernel)
def test_kernel_download(self, kernel):
spice.get_kernel(kernel)
def make_arrival_catalog_insitu_ssef30(higeocat,arrcat,ac_old, insitu_location_string, column_list):
#get parameters from HIGEOCAT for arrival catalog
higeocat_time=parse_time(higeocat['Date']).datetime #first HI observation
higeocat_t0=parse_time(higeocat['SSE Launch']).datetime #backprojected launch time
higeocat_t0_num=parse_time(higeocat_t0).plot_date
higeocat_vsse=np.array(higeocat['SSE Speed'])
higeocat_vsse_err=np.array(higeocat['SSE Speed Err'])
higeocat_sse_lon=np.array(higeocat['SSE HEEQ Long' ])
higeocat_sse_lat=np.array(higeocat['SSE HEEQ Lat' ])
higeocat_id=np.array(higeocat['ID'])
higeocat_sc=np.array(higeocat['SC'])
higeocat_pan=np.array(higeocat['PA-N'])
higeocat_pas=np.array(higeocat['PA-S'])
higeocat_pafit=np.array(higeocat['PA-fit'])
higeocat_pacenter=abs((higeocat_pan+higeocat_pas)/2)
#load spice here once for each spacecraft
if insitu_location_string=='STB':
insitu_str='-235'
insitu_kernel=spicedata.get_kernel('stereo_b')
target_name='STEREO-B'
if insitu_location_string=='STA':
insitu_str='-234'
insitu_kernel=spicedata.get_kernel('stereo_a_pred')
target_name='STEREO-A'
if insitu_location_string=='Mercury':
insitu_str='1'
insitu_kernel=spicedata.get_kernel('planet_trajectories')
target_name='Mercury'
if insitu_location_string=='Venus':
insitu_str='2'
insitu_kernel=spicedata.get_kernel('planet_trajectories')
target_name='Venus'
if insitu_location_string=='Earth':
insitu_str='3'
insitu_kernel=spicedata.get_kernel('planet_trajectories')
target_name='Earth_L1'
if insitu_location_string=='Mars':
insitu_str='4'
insitu_kernel=spicedata.get_kernel('planet_trajectories')
target_name='Mars'
if insitu_location_string=='PSP':
insitu_str='-96'
insitu_kernel=spicedata.get_kernel('psp_pred')
target_name='PSP'
if insitu_location_string=='Solo':
insitu_str='Solar Orbiter'
insitu_kernel=spicedata.get_kernel('solo_2020')
target_name='SolarOrbiter'
if insitu_location_string=='Bepi':
insitu_str='BEPICOLOMBO MPO'
insitu_kernel=spicedata.get_kernel('bepi_pred')
target_name='BepiColombo'
if insitu_location_string=='Ulysses':
insitu_str='ulysses'
insitu_kernel=spicedata.get_kernel('ulysses')
target_name='Ulysses'
spice.furnish(insitu_kernel)
#half width for SSEF30
lamda=30.0
#new version of ARRCAT with iteration
arrcat_insitu_list = []
#old version without iteration
arrcat_insitu_list_old = []
#go through all HIGEOCAT CME events and check for hit at insitu, with 4 iterations in total
for i in np.arange(len(higeocat_time)):
#get insitu position for launch time t0
[insitu_time,insitu_r,insitu_lat,insitu_lon]=get_insitu_position_time(higeocat_t0[i], insitu_location_string,insitu_str, insitu_kernel)
delta=abs(higeocat_sse_lon[i]-insitu_lon)
#print([insitu_time,insitu_r,insitu_lat,insitu_lon])
if delta < 30:
#calculate arrival time
#print(delta,lamda,insitu_r)
[ta,visse]=calculate_arrival(higeocat_vsse[i],delta, lamda, insitu_r,higeocat_t0_num[i])
#make old version of ARRCAT without iteration and errors
list_old=[higeocat_id[i].decode(),higeocat_sc[i].decode(),target_name,\
parse_time(higeocat_t0[i]).iso[:-7],parse_time(ta).iso[:-7],0,\
np.round(insitu_r,3), np.round(insitu_lon,2), np.round(insitu_lat,2),np.round(insitu_lon-higeocat_sse_lon[i],1),\
higeocat_sse_lon[i],higeocat_sse_lat[i],higeocat_vsse[i],\
higeocat_vsse_err[i], int(np.rint(visse)),0,higeocat_pafit[i],higeocat_pan[i],higeocat_pas[i],higeocat_pacenter[i]]
#print(list1)
arrcat_insitu_list_old.append(list_old)
[insitu_time2,insitu_r2,insitu_lat2,insitu_lon2]=get_insitu_position_time(ta, insitu_location_string,insitu_str, insitu_kernel)
#print(insitu_lon-insitu_lon2)
delta2=abs(higeocat_sse_lon[i]-insitu_lon2)
if delta2 <30:
[ta2,visse2]=calculate_arrival(higeocat_vsse[i],delta2, lamda, insitu_r2,higeocat_t0_num[i])
#print(int((parse_time(ta2).plot_date-parse_time(ta).plot_date)*24))
[insitu_time3,insitu_r3,insitu_lat3,insitu_lon3]=get_insitu_position_time(ta2, insitu_location_string,insitu_str, insitu_kernel)
delta3=abs(higeocat_sse_lon[i]-insitu_lon3)
if delta3 <30:
[ta3,visse3]=calculate_arrival(higeocat_vsse[i],delta3, lamda, insitu_r3,higeocat_t0_num[i])
#print(np.round((parse_time(ta3).plot_date-parse_time(ta2).plot_date)*24,1),int(delta3))
[insitu_time4,insitu_r4,insitu_lat4,insitu_lon4]=get_insitu_position_time(ta3, insitu_location_string,insitu_str, insitu_kernel)
delta4=abs(higeocat_sse_lon[i]-insitu_lon4)
if delta4 <30:
#calculate finally iterated arrival time
[ta4,visse4]=calculate_arrival(higeocat_vsse[i],delta4, lamda, insitu_r4,higeocat_t0_num[i])
#print(np.round((parse_time(ta4).plot_date-parse_time(ta3).plot_date)*24,1),int(delta4))
#print(int(delta4-delta))
#estimate error bar on arrival time adding or subtracting the error in the Vsse speed
[ta4_low,visse4_low]=calculate_arrival(higeocat_vsse[i]-higeocat_vsse_err[i],delta4, lamda, insitu_r4,higeocat_t0_num[i])
[ta4_high,visse4_high]=calculate_arrival(higeocat_vsse[i]+higeocat_vsse_err[i],delta4, lamda, insitu_r4,higeocat_t0_num[i])
#calculate difference in ours high / low to original arrival time and convert to hours
ta4_err_low=abs(parse_time(ta4).plot_date-parse_time(ta4_low).plot_date)*24
ta4_err_high=abs(parse_time(ta4).plot_date-parse_time(ta4_high).plot_date)*24
ta4_err=np.round(np.mean([ta4_err_high,ta4_err_low]),1)
#print(ta4_err_low,ta4_err_high,ta4_err)
#same for arrival speed error
visse4_err_low=abs(visse4_low-visse4)
visse4_err_high=abs(visse4_high-visse4)
visse4_err=int(np.rint(np.mean([visse4_err_high,visse4_err_low])))
#print(visse4_err_low,visse4_err_high,visse4_err,higeocat_vsse_err[i])
#print()
list1=[higeocat_id[i].decode(),higeocat_sc[i].decode(),target_name,\
parse_time(higeocat_t0[i]).iso[:-7],parse_time(ta4).iso[:-7],ta4_err,\
np.round(insitu_r4,3), np.round(insitu_lon4,2), np.round(insitu_lat4,2),np.round(insitu_lon4-higeocat_sse_lon[i],1),\
higeocat_sse_lon[i],higeocat_sse_lat[i],higeocat_vsse[i],\
higeocat_vsse_err[i], int(np.rint(visse4)),visse4_err,higeocat_pafit[i],higeocat_pan[i],higeocat_pas[i],higeocat_pacenter[i]]
#print(list1)
arrcat_insitu_list.append(list1)
#arrcat_insitu=np.array(arrcat_insitu_list)
#print(arrcat_insitu_list)
#make dataframe out of list
ac_old1 = pd.DataFrame(arrcat_insitu_list_old, columns = column_list)
ac_old=ac_old.append(ac_old1)
#make dataframe out of list
ac1 = pd.DataFrame(arrcat_insitu_list, columns = column_list)
arrcat=arrcat.append(ac1)
print('SSEF30 events: ',len(arrcat_insitu_list) )
print(insitu_location_string,' SSEF30 arrival catalog finished.')
print()
return [arrcat,ac_old]
def get_satellite_position_heliopy(satname, timestamp, refframe='J2000', refobject='Sun', rlonlat=False, returnobj=False):
"""Uses Heliopy's spice to get position information. Will automatically download
required kernels. Returns positions in km.
Parameters
==========
satname : str
Satellite name. Currently available: ['stereo_a', 'stereo_a_pred', 'earth']
timestamp : datetime / list of datetimes
Datetime objects to iterate through and return positions for.
refframe : str
String denoting reference frame to use for position.
refobject : str (default='Sun')
String for reference onject, e.g. 'Sun' or 'Earth'
rlonlat : bool (default=False)
If True, returns coordinates in (r, lon, lat) format, not (x,y,z).
returnobj : bool (default=False)
If True, returns heliopy.Trajectory object instead of arrays.
Returns
=======
If returnobj: returns heliopy.spice.Trajectory object.
else: returns tuple of (x,y,z) or (r,lon,lat) if rlonlat=True
"""
if isinstance(timestamp, datetime):
timestamp = [timestamp]
elif isinstance(timestamp, list):
pass
else:
logger.warning("get_satellite_position_heliopy: Don't recognise input timestamp format!")
if 'stereoa' in satname.lower().replace('-','').replace('_',''):
if 'pred' in satname.lower():
heliostr = 'stereo_a_pred'
else:
heliostr = 'stereo_a'
satstr = 'STEREO AHEAD'
elif 'stereob' in satname.lower().replace('-','').replace('_',''):
if 'pred' in satname.lower():
heliostr = 'stereo_b_pred'
else:
heliostr = 'stereo_b'
satstr = 'STEREO BEHIND'
elif satname.lower() in ['mercury', 'venus', 'earth', 'mars', 'jupiter', 'saturn', 'uranus', 'neptune']:
heliostr = 'planet_trajectories'
satstr = satname
hspice.furnish(spicedata.get_kernel(heliostr))
pos = hspice.Trajectory(satstr)
pos.generate_positions(timestamp, refobject, refframe)
if returnobj:
return pos
#pos.change_units('AU')
if rlonlat:
r, theta, phi = cart2sphere(pos.x, pos.y, pos.z)
return (r, phi, theta)
else:
return (pos.x, pos.y, pos.z)
"""
from datetime import datetime, timedelta
import matplotlib.pyplot as plt
import numpy as np
import astropy.units as u
import heliopy.data.spice as spicedata
import heliopy.spice as spice
###############################################################################
# Load the Solar Orbiter spice kernel. HelioPy will automatically fetch and
# load the latest kernel. We can then inspect the kernel to check what the
# date coverage is for Solar Orbiter.
kernels = spicedata.get_kernel('solo')
solo = spice.Trajectory('Solar Orbiter')
coverage = kernels[0].coverage(spice.Body('Solar Orbiter'))
print(coverage)
###############################################################################
# Next we define a set of times at which to sample the orbit.
starttime = coverage[0]
times = [starttime + timedelta(days=i) for i in range(1, 5 * 365)]
###############################################################################
# Generate positions. "IAU_SUN" is a Carrington frame of reference.
solo.generate_positions(times, 'Sun', 'IAU_SUN')
coords = solo.coords
###############################################################################
How to plot orbits from SPICE kernels.
In this example we download the Parker Solar Probe SPICE kernel, and plot
its orbit for the first year.
"""
import heliopy.data.spice as spicedata
import heliopy.spice as spice
from datetime import datetime, timedelta
import astropy.units as u
import numpy as np
###############################################################################
# Load the solar orbiter spice kernel. HelioPy will automatically fetch the
# latest kernel
kernels = spicedata.get_kernel('psp')
kernels += spicedata.get_kernel('psp_pred')
spice.furnish(kernels)
psp = spice.Trajectory('SPP')
###############################################################################
# Generate a time for every day between starttime and endtime
starttime = datetime(2018, 8, 14)
endtime = starttime + timedelta(days=365)
times = []
while starttime < endtime:
times.append(starttime)
starttime += timedelta(hours=6)
###############################################################################
# Generate positions