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)