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 furnish_spice_sse(probe: int):
if probe == 1:
spice.furnish('sse1.txt')
elif probe == 2:
spice.furnish('sse2.txt')
else:
raise NotImplementedError('Only Helios 1 and 2 work in SSE')
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_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 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 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
# ---
# - 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 solo_trajectory():
orbiter_kernel = spicedata.get_kernel('solo')
spice.furnish(orbiter_kernel)
return spice.Trajectory('Solar Orbiter')
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
psp.generate_positions(times, 'Sun', 'ECLIPJ2000')
psp.change_units(u.au)
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)
#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 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]
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')
orbiter.change_units(u.au)
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,
# ---
# - 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]:
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) )
def solo_trajectory():
orbiter_kernel = spicedata.get_kernel('helios1')
spice.furnish(orbiter_kernel)
return spice.Trajectory('Helios 1')
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)
