def get_pos_diff_between_spacecraft(sc1, sc2, date):
pos1 = get_horizons_coord(sc1, date)
pos2 = get_horizons_coord(sc2, date)
print('lon lat r (sc1):', pos1)
print('lon lat r (sc2):', pos2)
londiff = abs(pos1.lon.value - pos2.lon.value)
if londiff > 180.:
londiff = londiff - 360
if londiff < -180.:
londiff = 360 - abs(londiff)
latdiff = abs(pos1.lat.value - pos2.lat.value)
rdiff = pos1.radius.value - pos2.radius.value
diff = np.array([londiff, latdiff, rdiff])
return diff
def eit_correction(eitmap):
new_coords = get_horizons_coord(eitmap.observatory.replace(' ', '-'),
eitmap.date)
eitmap.meta['HGLN_OBS'] = new_coords.lon.to('deg').value
eitmap.meta['HGLT_OBS'] = new_coords.lat.to('deg').value
eitmap.meta['DSUN_OBS'] = new_coords.radius.to('m').value
eitmap.meta.pop('hec_x')
eitmap.meta.pop('hec_y')
eitmap.meta.pop('hec_z')
return eitmap
def get_long_sep(sc, date, flare_long, vsw=400):
'''
Determines the longitudinal separation angle of a given spacecraft and a given flare longitude
Parameters
----------
sc : `str`
The spacecraft for which to calculate positions.
'STEREO-A', 'STEREO-B', 'SOHO', 'MPO' (BepiColombo), 'PSP', 'SDO'
id_type : `str`
'''
if sc in ['Earth', 'EARTH']:
pos = get_horizons_coord(399, date, 'id')
else:
pos = get_horizons_coord(sc,
date) # (lon, lat, radius) in (deg, deg, AU)
pos = pos.transform_to(frames.HeliographicCarrington)
lon = pos.lon.value
dist = pos.radius.value
omega = math.radians(
360. / (25.38 * 24 * 60 * 60)) # rot-angle in rad/sec, sidereal period
tt = dist * AU / vsw
alpha = math.degrees(omega * tt)
long_sep = flare_long - (lon + alpha)
if long_sep > 180.:
long_sep = long_sep - 360
if long_sep < -180.:
long_sep = 360 - abs(long_sep)
print('spacecraft: {}'.format(sc))
print('alpha: {:.1f}°'.format(alpha))
print('lon: {:.1f}°'.format(lon))
print('v_sw: {:.1f} km/s'.format(vsw))
print('Longitudinal separation: {:.1f}°'.format(long_sep))
print()
return long_sep
def download_helioviewer(date, observatory, instrument, detector):
file = hv.download_jp2(date,
observatory=observatory,
instrument=instrument,
detector=detector)
f = Map(file)
if observatory == 'SOHO':
# add observer location information:
soho = get_horizons_coord('SOHO', f.date)
f.meta['HGLN_OBS'] = soho.lon.to('deg').value
f.meta['HGLT_OBS'] = soho.lat.to('deg').value
f.meta['DSUN_OBS'] = soho.radius.to('m').value
return f
nx_euvir, ny_euvir = euvir_maps[0].data.shape
for file_nb in range(nb_files):
# Make map objects for one channel
eit_maps = sunpy.map.Map(filenames_eit_0[file_nb])
euvil_maps = sunpy.map.Map(filenames_euvil_0[file_nb])
euvir_maps = sunpy.map.Map(filenames_euvir_0[file_nb])
filename_extract = filenames_eit_0[file_nb].split(path_to_files +
str(list_channels[0]))
filename_output = output_path + 'composite_' + filename_extract[1]
print(filename_extract)
print('here')
if eit_maps.observatory in ['SOHO']:
new_coords = get_horizons_coord(eit_maps.observatory.replace(' ', '-'),
eit_maps.date)
eit_maps.meta['HGLN_OBS'] = new_coords.lon.to('deg').value
eit_maps.meta['HGLT_OBS'] = new_coords.lat.to('deg').value
eit_maps.meta['DSUN_OBS'] = new_coords.radius.to('m').value
eit_maps.meta.pop('hec_x')
eit_maps.meta.pop('hec_y')
eit_maps.meta.pop('hec_z')
# Check positioning of instruments in order to cover full Sun
long_eit = eit_maps.observer_coordinate.lon.to('degree')
print(long_eit.value)
long_euvil = euvil_maps.observer_coordinate.lon.to('degree') - long_eit
print(long_euvil.value)
long_euvir = euvir_maps.observer_coordinate.lon.to('degree') - long_eit
print(long_euvir.value)
if -90 < long_euvil.value < 90 and -90 < long_euvir.value < 90:
def eit_correction(eitmap):
if eitmap.observatory in ['SOHO']:
new_coords = get_horizons_coord(eitmap.observatory.replace(' ', '-'),
eitmap.date)
eitmap.meta['HGLN_OBS'] = new_coords.lon.to('deg').value
eitmap.meta['HGLT_OBS'] = new_coords.lat.to('deg').value
eitmap.meta['DSUN_OBS'] = new_coords.radius.to('m').value
eitmap.meta.pop('hec_x')
eitmap.meta.pop('hec_y')
eitmap.meta.pop('hec_z')
return eitmap
# Nb. of channels
def satellite_position(map1,map2,map3):
map1=
if map1.observatory in ['SOHO']:
long_eit =map1.observer_coordinate.lon.to('degree')
long_eit = eit_maps.observer_coordinate.lon.to('degree')
print(long_eit.value)
long_euvil = euvil_maps.observer_coordinate.lon.to('degree')-long_eit
print(long_euvil.value)
long_euvir = euvir_maps.observer_coordinate.lon.to('degree')-long_eit
print(long_euvir.value)
if -90 < long_euvil.value < 90 and -90 < long_euvir.value < 90:
position_condition = 0
elif 90 < long_euvil.value < 180 and long_euvil.value-180 < long_euvir.value < 180:
position_condition = 0
elif 90 < long_euvir.value < 180 and long_euvir.value-180 < long_euvil.value < 180:
position_condition = 0
elif -180 < long_euvil.value < -90 and -180 < long_euvir.value < long_euvil.value+180:
position_condition = 0
elif -180 < long_euvir.value < -90 and -180 < long_euvil.value < long_euvir.value+180:
position_condition = 0
else:
position_condition = 1
nb_channels = 3
list_channels = [171, 195, 304]
# Find sample data
path_to_files = '/home/ajt/Downloads/Hackweek_data/EUV_data/'
filenames_eit_195 = sorted(glob.glob(path_to_files+'EIT_'+'*195*' +'.fits'))
filenames_euvil_195 = sorted(glob.glob(path_to_files+'EIT_'+'*195*' +'.fits'))
filenames_euvir_195 = sorted(glob.glob(path_to_files+'EIT_'+'*195*' +'.fits'))
filenames_eit_171 = sorted(glob.glob(path_to_files+'EIT_'+'*171*' +'.fits'))
filenames_euvil_171 = sorted(glob.glob(path_to_files+'EIT_'+'*171*' +'.fits'))
filenames_euvir_171 = sorted(glob.glob(path_to_files+'EIT_'+'*171*' +'.fits'))
filenames_eit_304 = sorted(glob.glob(path_to_files+'EIT_'+'*304*' +'.fits'))
filenames_euvil_304 = sorted(glob.glob(path_to_files+'EIT_'+'*304*' +'.fits'))
filenames_euvir_304 = sorted(glob.glob(path_to_files+'EIT_'+'*304*' +'.fits'))
# Nb. of samples to work with
nb_files = max(len(filenames_euvil_171), len(filenames_euvir_171),len(filenames_eit_171))
# Hamada class for homogenization
filename = 'cumulative_hist.npz'
hamada_model = hamada_hist_matching.hamada(filename='cumulative_hist.npz')
np.datetime64('2015-07-04 12:59:59.50')
'''
STOP UNCHECKED AFTER THIS LINE
'''
# Output
output_path = '/home/plasmion/'
eit_maps = sunpy.map.Map(filenames_eit)
nx_eit, ny_eit = eit_maps[0].data.shape
euvil_maps = sunpy.map.Map(filenames_euvil)
nx_euvil, ny_euvil = euvil_maps[0].data.shape
euvir_maps = sunpy.map.Map(filenames_euvir)
nx_euvir, ny_euvir = euvir_maps[0].data.shape
for file_nb in range(len(list_channels)):
# Make map objects for one channel
eit_maps_171 = sunpy.map.Map(filenames_eit_171)
euvil_maps_171= sunpy.map.Map(filenames_euvil_171)
euvir_maps_171 = sunpy.map.Map(filenames_euvir_171)
eit_maps_171=eit_correction(eit_maps_171)
filename_extract = filenames_eit_0[file_nb].split(path_to_files+str(list_channels[0]))
filename_output = output_path + 'composite_' + filename_extract[1]
print(filename_extract)
print('here')
nx_eit_171, ny_eit_171 = eit_maps_171.data.shape
nx_euvil, ny_euvil = euvil_maps_171.data.shape
nx_euvir, ny_euvir = euvir_maps_171.data.shape
# Check positioning of instruments in order to cover full Sun
# Mask everything outside the solar disk
where_mask = mask_outside_disk(eit_maps)
eit_maps.data[where_mask] = np.nan
where_mask = mask_outside_disk(euvil_maps)
euvil_maps.data[where_mask] = np.nan
where_mask = mask_outside_disk(euvir_maps)
euvir_maps.data[where_mask] = np.nan
maps_list=[eit_maps,euvil_maps,euvir_maps]
# Wavelet enchancement of the EIT data for improved contrast
# Missing Step ######################
# arr_tmp = eit_maps.data
# eit_maps.data = wavelet_enhancement(arr_tmp)
# Homogenization of the EIT data /w respect to EUVI
outmap = combine_maps(maps_list)
outmap.plot_settings = maps_list[0].plot_settings
outmap.nickname = 'EIT + EUVI/A + EUVI/B'
# Output
outmap.save(filename_output, filetype='fits', overwrite=True)
fig = plt.figure(figsize=(5, 6))
ax = fig.add_subplot(111, projection=aia_submap)
aia_submap.plot()
aia_submap.draw_limb()
aia_submap.draw_grid()
fig.tight_layout()
plt.show()
# ## More coordinates
# In[6]:
from sunpy.coordinates import get_horizons_coord
sdo_pos = get_horizons_coord('SDO', aia_map.date)
venus_pos = get_horizons_coord('Venus barycenter', aia_map.date)
helio_plot(sdo_pos, venus_pos)
# In[7]:
from sunpy.coordinates import frames
#Create an observer looking to the (-900,0) of the sun
spice_pointing = {'x': -900 * u.arcsec, 'y': 0 * u.arcsec}
spice_FOV = {'width': 8 * u.arcmin, 'height': 11 * u.arcmin} # (480 slits)
spice_corners = get_corners(spice_pointing, spice_FOV)
spice_obs = SkyCoord(spice_corners,
observer=venus_pos,
def __init__(self,
date,
body_list,
vsw_list=[],
reference_long=None,
reference_lat=None):
body_list = list(dict.fromkeys(body_list))
bodies = deepcopy(body_dict)
self.date = date
self.reference_long = reference_long
self.reference_lat = reference_lat
pos_E = get_horizons_coord(
399, self.date, 'id') # (lon, lat, radius) in (deg, deg, AU)
self.pos_E = pos_E.transform_to(
frames.HeliographicCarrington(observer='Sun'))
if len(vsw_list) == 0:
vsw_list = np.zeros(len(body_list)) + 400
random_cols = [
'forestgreen', 'mediumblue', 'm', 'saddlebrown', 'tomato', 'olive',
'steelblue', 'darkmagenta', 'c', 'darkslategray', 'yellow',
'darkolivegreen'
]
body_lon_list = []
body_lat_list = []
body_dist_list = []
longsep_E_list = []
latsep_E_list = []
body_vsw_list = []
footp_long_list = []
longsep_list = []
latsep_list = []
footp_longsep_list = []
for i, body in enumerate(body_list.copy()):
if body in bodies:
body_id = bodies[body][0]
body_lab = bodies[body][1]
body_color = bodies[body][2]
else:
body_id = body
body_lab = str(body)
body_color = random_cols[i]
bodies.update(
dict.fromkeys([body_id], [body_id, body_lab, body_color]))
try:
pos = get_horizons_coord(
body_id, date,
'id') # (lon, lat, radius) in (deg, deg, AU)
pos = pos.transform_to(
frames.HeliographicCarrington(observer='Sun'))
bodies[body_id].append(pos)
bodies[body_id].append(vsw_list[i])
longsep_E = pos.lon.value - self.pos_E.lon.value
if longsep_E > 180:
longsep_E = longsep_E - 360.
latsep_E = pos.lat.value - self.pos_E.lat.value
body_lon_list.append(pos.lon.value)
body_lat_list.append(pos.lat.value)
body_dist_list.append(pos.radius.value)
longsep_E_list.append(longsep_E)
latsep_E_list.append(latsep_E)
body_vsw_list.append(vsw_list[i])
sep, alpha = self.backmapping(pos,
date,
reference_long,
vsw=vsw_list[i])
bodies[body_id].append(sep)
body_footp_long = pos.lon.value + alpha
if body_footp_long > 360:
body_footp_long = body_footp_long - 360
footp_long_list.append(body_footp_long)
if self.reference_long is not None:
bodies[body_id].append(sep)
long_sep = pos.lon.value - self.reference_long
if long_sep > 180:
long_sep = long_sep - 360.
longsep_list.append(long_sep)
footp_longsep_list.append(sep)
if self.reference_lat is not None:
lat_sep = pos.lat.value - self.reference_lat
latsep_list.append(lat_sep)
except ValueError:
print('')
print('!!! No ephemeris for target "' + str(body) +
'" for date ' + self.date)
body_list.remove(body)
body_dict_short = {sel_key: bodies[sel_key] for sel_key in body_list}
self.body_dict = body_dict_short
self.max_dist = np.max(body_dist_list)
self.coord_table = pd.DataFrame({
'Spacecraft/Body':
list(self.body_dict.keys()),
'Carrington Longitude (°)':
body_lon_list,
'Latitude (°)':
body_lat_list,
'Heliocentric Distance (AU)':
body_dist_list,
"Longitudinal separation to Earth's longitude":
longsep_E_list,
"Latitudinal separation to Earth's latitude":
latsep_E_list,
'Vsw':
body_vsw_list,
'Magnetic footpoint longitude (Carrington)':
footp_long_list
})
if self.reference_long is not None:
self.coord_table[
'Longitudinal separation between body and reference_long'] = longsep_list
self.coord_table[
"Longitudinal separation between body's mangetic footpoint and reference_long"] = footp_longsep_list
if self.reference_lat is not None:
self.coord_table[
'Latitudinal separation between body and reference_lat'] = latsep_list
pass
self.coord_table.style.set_properties(**{'text-align': 'left'})
def make_the_plot(date, sc_list, vsw_list, flare_long):
fig, ax = plt.subplots(subplot_kw=dict(projection='polar'), figsize=(8, 8))
r = np.arange(0.007, 1.3, 0.001)
if len(vsw_list) == 0:
vsw_list = np.zeros(len(sc_list)) + 400
color_dic = {
'STEREO-A': 'red',
'STEREO-B': 'blue',
'Earth': 'green',
'MPO': 'orange',
'PSP': 'purple',
'SolarOrbiter': 'dodgerblue'
}
for i, sc in enumerate(sc_list):
sc_color = color_dic[sc]
sep = get_long_sep(sc, date, flare_long, vsw=vsw_list[i])
if sc in ['Earth', 'EARTH']:
pos = get_horizons_coord(399, date, 'id')
else:
pos = get_horizons_coord(
sc, date) # (lon, lat, radius) in (deg, deg, AU)
pos = pos.transform_to(frames.HeliographicCarrington)
dist_a = pos.radius.value
sc_long = pos.lon.value
v_A = vsw_list[i]
pos_E = get_horizons_coord(
399, date, 'id') # (lon, lat, radius) in (deg, deg, AU)
pos_E = pos_E.transform_to(frames.HeliographicCarrington)
E_long = pos_E.lon.value
dist_e = pos_E.radius.value
omega = np.radians(
360. /
(25.38 * 24 * 60 * 60)) # rot-angle in rad/sec, sidereal period
tt = dist_a * AU / vsw_list[i]
alpha = np.degrees(omega * tt)
sc_long_shifted = sc_long - E_long
if sc_long_shifted < 0.:
sc_long_shifted = sc_long_shifted + 360.
delta_flare = flare_long - E_long
if delta_flare < 0.:
delta_flare = delta_flare + 360.
A_west_spiral = np.radians(sc_long_shifted)
alpha_f = np.deg2rad(delta_flare) + omega / (v_A / AU) * (
dist_e / AU - r) - (omega / (v_A / AU) * (dist_e / AU))
alpha_A = np.deg2rad(sc_long_shifted) + omega / (v_A / AU) * (dist_a -
r)
ax.plot(alpha_A, r, color=sc_color)
ax.plot(np.deg2rad(sc_long_shifted),
dist_a,
's',
color=sc_color,
label=sc)
ax.plot(alpha_f, r, '--k')
arr1 = plt.arrow(alpha_f[0],
0.01,
0,
1.1,
head_width=0.12,
head_length=0.11,
edgecolor='black',
facecolor='black',
lw=2,
zorder=5,
overhang=0.2)
plt.subplots_adjust(left=0.2, bottom=0.1, right=0.8,
top=0.8) # , wspace=None, hspace=None)
ax.legend(loc=1, bbox_to_anchor=(1.3, 1.3))
ax.set_rlabel_position(120)
ax.set_theta_zero_location("S")
ax.set_rmax(1.3)
ax.set_rmin(0.01)
ax.set_title(date + '\n')
plt.show()
