def create_graphs(file_path, event, site_data, fov=30):
"""Create airmass and finder plots."""
# Plot airmass during the night
delta_t = site_data['sun_rise'] - site_data['sun_set']
time_range = site_data['sun_set'] + delta_t * np.linspace(0, 1, 75)
plot_airmass(event.coord,
site_data['observer'],
time_range,
altitude_yaxis=True,
style_sheet=dark_style_sheet)
airmass_file = "{}_AIRMASS.png".format(event.name)
plt.savefig(os.path.join(file_path, 'airmass_plots', airmass_file))
plt.clf()
# Plot finder chart
import warnings
with warnings.catch_warnings():
warnings.simplefilter('ignore')
plot_finder_image(event.target,
fov_radius=fov * u.arcmin,
grid=False,
reticle=True)
airmass_file = "{}_FINDER.png".format(event.name)
plt.savefig(os.path.join(file_path, 'finder_charts', airmass_file))
plt.clf()
def airmass_altitude_plot_given_target(name_observatory,
day,
target,
path_target_list=None):
"""
Parameters
----------
name_observatory : str
name of the observatory
day : date
date in format 'yyyy-mm-dd'
target : str
name of target
path_target_list : path
path of the target list
Returns
-------
"""
if path_target_list is None:
path_target_list = path_spock + '/target_lists/speculoos_target_list_v6.txt'
observatory = charge_observatories(name_observatory)[0]
delta_midnight = Time(np.linspace(observatory.twilight_evening_nautical(day, which='next').jd - 0.07, \
observatory.twilight_morning_nautical(day + 1, which='nearest').jd + 0.07, 100),
format='jd')
sun_set = observatory.twilight_evening_nautical(day, which='next').iso
sun_rise = observatory.twilight_morning_nautical(day + 1,
which='nearest').iso
target_list = pd.read_csv(path_target_list, delimiter=' ')
idx_target_list = list(target_list['Sp_ID']).index(target)
fig, axs = plt.subplots(1, figsize=(9, 7))
colors_start_new_target = ['black', 'darkgray', 'lightgray']
dec = target_list['DEC'][idx_target_list]
ra = target_list['RA'][idx_target_list]
plot_styles = {'linestyle': '-', 'color': 'k'}
if name_observatory == 'SSO':
plot_styles = {'linestyle': '-', 'color': 'skyblue'}
if name_observatory == 'SNO':
plot_styles = {'linestyle': '-', 'color': 'teal'}
if name_observatory == 'Saint-Ex':
plot_styles = {'linestyle': '-', 'color': 'gold'}
plot_airmass(FixedTarget(coord=SkyCoord(ra=ra, dec=dec, unit=(u.deg, u.deg)), \
name=target), observatory, delta_midnight, brightness_shading=True, altitude_yaxis=True,
style_kwargs=plot_styles)
#axs.vlines(sun_set, 3, 1, linestyle='--', color='orange', alpha=0.9, linewidth=2)
#axs.vlines(sun_rise, 3, 1, linestyle='--', color='orange', alpha=0.9, linewidth=2)
plt.ylabel('Altitude (degrees)')
plt.grid(color='gainsboro', linestyle='-', linewidth=1, alpha=0.3)
plt.title('Visibility plot for ' + target + ' on the ' +
str(day.tt.datetime.strftime("%Y-%m-%d")) + ' at ' +
name_observatory,
y=-0.01)
#plt.title('Visibility plot for target ' + target + ' on the ' + str(day.tt.datetime.strftime("%Y-%m-%d")))
plt.show()
def airmass_plots(KPNO=False,ING=False,MLO=False):
observer_site = Observer.at_site("Kitt Peak", timezone="US/Mountain")
if KPNO:
print('plotting airmass curves for Kitt Peak')
observing_location = EarthLocation.of_site('Kitt Peak')
observer_site = Observer.at_site("Kitt Peak", timezone="US/Mountain")
start_time = Time('2017-03-12 01:00:00') # UTC time, so 1:00 UTC = 6 pm AZ mountain time
end_time = Time('2017-03-12 14:00:00')
elif MLO:
print('plotting airmass curves for MLO')
observing_location = EarthLocation.of_site(u'Palomar')
observer_site = Observer.at_site("Palomar", timezone="US/Pacific")
# for run starting 2019-Apr-04 at MLO
start_time = Time('2019-04-03 01:00:00') # need to enter UTC time, MLO UTC+6?
end_time = Time('2019-04-03 14:00:00')
elif ING:
print('plotting airmass curves for INT')
observing_location = EarthLocation.of_site(u'Roque de los Muchachos')
observer_site = Observer.at_site("Roque de los Muchachos", timezone="GMT")
# for run starting 2019-Feb-04 at INT
start_time = Time('2019-02-04 19:00:00') # INT is on UTC
end_time = Time('2019-02-05 07:00:00')
#observing_time = Time('2017-05-19 07:00') # 1am UTC=6pm AZ mountain time
#observing_time = Time('2018-03-12 07:00') # 1am UTC=6pm AZ mountain time
#aa = AltAz(location=observing_location, obstime=observing_time)
#for i in range(len(pointing_ra)):
delta_t = end_time - start_time
observing_time = start_time + delta_t*np.linspace(0, 1, 75)
nplots = int(sum(obs_mass_flag)/8.)
print(nplots)
for j in range(nplots):
plt.figure()
legend_list = []
for i in range(8):
pointing_center = coords.SkyCoord(pointing_ra[8*j+i]*u.deg, pointing_dec[8*j+i]*u.deg, frame='icrs')
if i == 3:
plot_airmass(pointing_center,observer_site,observing_time,brightness_shading=True)
else:
plot_airmass(pointing_center,observer_site,observing_time)
legend_list.append('Pointing %02d'%(8*j+i+1))
plt.legend(legend_list)
#plt.ylim(0.9,2.5)
plt.gca().invert_yaxis()
plt.subplots_adjust(bottom=.15)
#plt.axvline(x=7*u.hour,ls='--',color='k')
plt.axhline(y=2,ls='--',color='k')
plt.savefig(outfile_prefix+'airmass-%02d.png'%(j+1))
def airmass_altitude_plot_saved(name_observatory, telescope, day):
"""
Parameters
----------
name_observatory : str
name of the observatory (ex : 'SSO')
telescope : str
name of the telescope (exx : 'Io')
day : date
date of day in fmt "yyyy-mm-dd"
Returns
-------
plot
visibility plot on telescope at a given day
"""
night_block = pd.read_csv(os.path.join(path_spock + '/DATABASE/', telescope,
'Archive_night_blocks','night_blocks_' + telescope + '_' + day.tt.datetime.strftime("%Y-%m-%d") + '.txt'),\
sep=' ', skipinitialspace=True)
observatory = charge_observatories(name_observatory)[0]
day = Time(night_block['start time (UTC)'][0]) - 5 * u.hour
delta_midnight = Time(np.linspace(observatory.twilight_evening_nautical(day,which='next').jd - 0.07,\
observatory.twilight_morning_nautical(day+1,which='nearest').jd + 0.07, 100),format='jd')
sun_set = observatory.twilight_evening_nautical(day, which='next').iso
sun_rise = observatory.twilight_morning_nautical(day + 1,
which='nearest').iso
fig, axs = plt.subplots(1)
colors_start_new_target = ['black', 'darkgray', 'lightgray']
for i in range(len(night_block)):
dec = str(int(float(night_block['dec (d)'][i]))) + ' ' + str(
int(abs(float(night_block['dec (m)'][i])))) + ' ' + str(
int(abs(float(night_block['dec (s)'][i]))))
ra = str(int(float(night_block['ra (h)'][i]))) + ' ' + str(
int(abs(float(night_block['ra (m)'][i])))) + ' ' + str(
int(abs(float(night_block['ra (s)'][i]))))
plot_airmass(FixedTarget(coord=SkyCoord(ra=ra,dec=dec,unit=(u.hourangle, u.deg)),\
name=night_block['target'][i]), observatory, delta_midnight, altitude_yaxis=True)
plt.ylabel('Altitude (degrees)')
t = Time(night_block['start time (UTC)'][i])
axs.vlines(t.iso,
3,
1,
linestyle='--',
color=colors_start_new_target[i],
alpha=0.7,
label='start ' + str(night_block['target'][i]))
axs.vlines(sun_set, 3, 1, linestyle=':', color='yellow', alpha=0.9)
axs.vlines(sun_rise, 3, 1, linestyle=':', color='yellow', alpha=0.9)
#plt.legend(loc=2)
plt.grid(color='gainsboro', linestyle='-', linewidth=1, alpha=0.3)
plt.title('Visibility plot for the night of the ' +
str(day.tt.datetime.strftime("%Y-%m-%d")) + ' on ' +
str(telescope))
def _make_figure(self, xlim=None, ylim=None, ax=None):
if ax:
self.ax = ax
plot_airmass(self.coord,
self.observer,
self.time,
ax=self.ax,
altitude_yaxis=True,
brightness_shading=True)
self.ax.tick_params(labelsize=8)
def sortie_graphique(self, etoile_cible, date_obs, observatoire):
matplotlib.rcParams['backend'] = 'Qt5Agg'
# Etoiles
etoile = FixedTarget(etoile_cible['equat'], name=etoile_cible['nom'])
# Intervalle de temps
temps_obs = Time(date_obs)
debut = temps_obs - TimeDelta(10800.0, format='sec')
fin = temps_obs + TimeDelta(10800.0, format='sec')
delta_t = fin - debut
intervalle_temps_1 = debut + delta_t * np.linspace(0, 1, 75)
intervalle_temps_2 = debut + delta_t * np.linspace(0, 1, 11)
# Observatoire
obs = Observer(location=observatoire, timezone="UTC")
# Masse d'air
if self.graph1 is None:
self.fig1, self.graph1 = plt.subplots()
else:
self.graph1.clear()
plot_airmass(etoile,
obs,
intervalle_temps_1,
ax=self.graph1,
altitude_yaxis=True,
max_region=2.0)
self.graph1.legend(shadow=True, loc='best')
plt.tight_layout()
# Carte
# Il faut obligatoirement que le graphique soit en mode polaire avant l'appel à plot_sky
if self.graph2 is None:
self.fig2, self.graph2 = plt.subplots(
subplot_kw=dict([('projection', 'polar')]))
else:
self.graph2.clear()
style = {'marker': '.'}
plot_sky(etoile,
obs,
intervalle_temps_2,
ax=self.graph2,
style_kwargs=style)
self.graph2.legend(shadow=True, loc='best')
plt.tight_layout()
plt.show(block=False)
plt.pause(.1)
def airmass_png():
# Parse the arguments
location = flask.request.args.get('location', default=None, type=str)
targets = flask.request.args.get('targets', default=None, type=str)
observer = astroplan.Observer.at_site(location)
targets = _parse_targets(targets)
time = Time.now()
# Create the airmass plot
fig = pl.figure()
ax = fig.add_subplot(111)
plot_airmass(targets[0], observer, time, ax=ax)
pl.tight_layout()
# Stream the image to the browser using BytesIO
img = BytesIO()
fig.savefig(img)
img.seek(0)
response = flask.send_file(img, mimetype="image/png")
return response
def main():
site = Observer.at_site('Las Campanas Observatory')
ra = "07:21:28.72"
dec = "-45:34:03.85"
name = "TIC_59859387.01"
start_time = Time('2020-02-05 23:30:00')
end_time = Time('2020-02-06 09:30:00')
##########################################
range_time = end_time - start_time
observe_time = start_time + range_time*np.linspace(0,1,100)
if (isinstance(ra, u.quantity.Quantity) and
isinstance(dec, u.quantity.Quantity)
):
target_coord = SkyCoord(ra=ra, dec=dec)
elif (isinstance(ra, str) and
isinstance(dec, str)
):
target_coord = SkyCoord(ra=ra, dec=dec, unit=(u.hourangle, u.deg))
else:
raise NotImplementedError
target = FixedTarget(coord=target_coord, name=name)
outdir = "../results/{}".format(name)
if not os.path.exists(outdir):
os.mkdir(outdir)
outname = '{}_{}_start{}_airmass.png'.format(
name, site.name.replace(' ','_'), repr(start_time.value)
)
outpath = os.path.join(outdir,outname)
plot_airmass(target, site, observe_time, style_sheet=dark_style_sheet,
altitude_yaxis=True)
plt.tight_layout()
plt.savefig(outpath, dpi=250, bbox_inches='tight')
print('made {}'.format(outpath))
def plot_all(startimes, endtimes, midtimes, duration, target, obs):
n = len(startimes)
w = int(np.ceil(np.sqrt(n)))
h = int(np.ceil(n/w))
half_duration = datetime.timedelta(hours=0.5*duration[0])
fig, axs = plt.subplots(w,h,figsize=(3*h,3*w),sharey=True)
m = 0
for i in np.arange(w):
for j in np.arange(h):
if m>=n:
axs[i,j].set_visible(False)
continue
year = midtimes[m][6:10]
mid_time = Time(year + '-' + midtimes[m].replace('/','-').replace('-%s'%year,'') + ':00')
start_time = -1*half_duration + mid_time.datetime
end_time = half_duration + mid_time.datetime
# add airmass plot - sample airmass time window from UT 0 so x axis reads correct data - created start of grid by dumb hack of taking start_time and subtracting start_time.hour
dt_array = np.arange(0,30,0.1)
time_array = [start_time - datetime.timedelta(hours=start_time.hour) + datetime.timedelta(hours=q) for q in dt_array]
ax = plot_airmass(target, obs, time_array, ax=axs[i,j],brightness_shading=False, altitude_yaxis=False)
# get moon info
moon_ill = round(moon.moon_illumination(mid_time),2)
moon_coord = moon.get_moon(mid_time,location=obs.location)
moon_sep = np.abs(moon_coord.ra - target.ra)
axs[i,j].axvspan(start_time, end_time,ymin=0, ymax=10, color='plum',alpha=0.8)
# narrower x-axis
xlo = datetime.datetime(day=start_time.day, year=start_time.year, month= start_time.month)
axs[i,j].set_xlim(xlo + datetime.timedelta(hours=4),xlo + datetime.timedelta(hours=17))
# Put moon info in each panel
txt_shift = 5 if start_time.hour > 8 else 12
txt = axs[i,j].annotate('moon:%s\n%sdeg'%(moon_ill,round(moon_sep.value)),\
(xlo + datetime.timedelta(hours=txt_shift),2.5),\
fontsize=8)
txt.set_bbox(dict(facecolor='white', alpha=0.5))
start = start_time - datetime.timedelta(hours=10)
twilight1 =obs.twilight_evening_astronomical(Time(start), which='next').datetime
twilight2 = obs.twilight_morning_astronomical(Time(start), which='next').datetime
ax.axvspan(twilight1, twilight2, ymin=0, ymax=1, color='lightgrey',zorder=-10)
fig.suptitle(planet + ' from ' + site, fontsize=18)
m+=1
plt.subplots_adjust(hspace=0.6,top=0.92)
def affichage_masse_air(self, etoile_cible, selection_etoiles, date_obs,
observatoire):
# Etoiles
# Bogue dans plot_airmass : le 1er FixedTarget ne génère pas de légende. Donc on duplique le 1er enregistrement dans la liste
etoiles = [
FixedTarget(etoile_cible['equat'], name=etoile_cible['nom']),
[FixedTarget(etoile_cible['equat'], name=etoile_cible['nom'])]
]
for etoile in selection_etoiles:
if len(etoiles) > 6:
break
if (etoile['Sp'] in type_pickles) or etoile['Miles']:
etoiles.append(
FixedTarget(etoile['equat'], name=etoile['Name']))
# Intervalle de temps
temps_obs = Time(date_obs)
debut = temps_obs - TimeDelta(10800.0, format='sec')
fin = temps_obs + TimeDelta(10800.0, format='sec')
delta_t = fin - debut
intervalle_temps = debut + delta_t * np.linspace(0, 1, 75)
# Observatoire
obs = Observer(location=observatoire, timezone="UTC")
# Graphique
# Nettoyage d'un éventuel graphique pré-existant
if self.graphique_masse_air:
self.graphique_masse_air.clear()
plt.pause(.1)
# Affichage
self.graphique_masse_air = plot_airmass(etoiles,
obs,
intervalle_temps,
altitude_yaxis=True,
brightness_shading=True,
max_region=2.0)
self.graphique_masse_air.legend(shadow=True, loc='best')
plt.tight_layout()
plt.show(block=False)
plt.pause(.1)
def airmass(ra=0.,
dec=0.,
obs='apo',
date='2019-10-01',
name='object',
plot=False,
tz='US/Mountain'):
""" Get airmass table for specified object position, observatory, date
"""
# set the site
site = Observer.at_site(obs, timezone=tz)
# set the objects
if type(ra) is float:
obj = FixedTarget(name=name,
coord=SkyCoord(str(ra) + 'd',
str(dec) + 'd'))
else:
obj = FixedTarget(name=name, coord=SkyCoord(ra + 'h', dec + 'd'))
time = Time('{:s} 00:00:00'.format(date),
scale='utc',
location=(site.location.lon, site.location.lat),
precision=0)
sunset = site.sun_set_time(time)
civil = site.twilight_evening_civil(time)
nautical = site.twilight_evening_nautical(time)
astronomical = site.twilight_evening_astronomical(time)
for t in [sunset, civil, nautical, astronomical]:
t.format = 'isot'
t.precision = 0
print('Observatory: ', obs)
print('Sunset: ', sunset)
print('Civil twilight: ', civil)
print('Nautical twilight: ', nautical)
print('Astronomical twilight: ', astronomical)
# loop over all UTC hours for this date (would prefer local!)
print('{:8s}{:8s}{:8s}{:8s}{:8s}{:9s}{:8s}{:8s} {:16s}{:20s}'.format(
'Local', 'UT', 'LST', 'HA', 'Airmass', 'ParAng', 'Phase', 'Moon Alt',
'Moon RA', 'Moon DEC'))
for hr in np.arange(24):
time = Time('{:s} {:d}:00:00'.format(date, hr),
scale='utc',
location=(site.location.lon, site.location.lat),
precision=0)
sun = get_sun(time)
if site.sun_altaz(time).alt.value > 10: continue
moon = get_moon(time)
val = site.altaz(time, obj).secz
if val < 0:
airmass = ' ...'
else:
airmass = '{:8.2f}'.format(val)
val = site.moon_altaz(time).alt.value
if val < 0:
moonalt = ' ...'
else:
moonalt = '{:8.2f}'.format(val)
lst = time.sidereal_time('mean').hms
ha = site.target_hour_angle(time, obj)
ha.wrap_angle = 180 * units.deg
local = site.astropy_time_to_datetime(time)
print(
'{:02d}:{:02d} {:02d}:{:02d} {:02d}:{:02d} {:3d}:{:02d} {:8s} {:8.2f} {:8.2f} {:8s} {:s} {:s}'
.format(
local.hour,
local.minute,
time.datetime.hour,
time.datetime.minute,
int(round(lst[0])),
int(round(lst[1])),
int(round(ha.hms[0])),
int(abs(round(ha.hms[1]))),
airmass,
#site.altaz(time,obj).secz,
site.parallactic_angle(time, obj).deg,
astroplan.moon_illumination(time),
moonalt,
str(moon.ra.to_string(units.hour)),
str(moon.dec)))
if plot:
fig, ax = plt.subplots(2, 1)
fig.subplots_adjust(hspace=0.001)
plot_airmass(obj, site, time, ax=ax[0])
plot_parallactic(obj, site, time, ax=ax[1])
def plot(date, objects):
# In[ ]:
print(objects)
#This tool is designed for the Magellan Telescope @ Las Camapanas Observatory, in Chile
las = Observer.at_site('LCO')
#both las and los are the locations of MagAO, but one is used for the plot and the other for the time
lco = EarthLocation.of_site('Las Campanas Observatory')
# In[ ]:
start_time = las.sun_set_time(Time(date), which='nearest')
end_time = las.sun_rise_time(Time(date), which='nearest')
date = start_time.iso[:10] + ' to ' + end_time.iso[:10]
# In[ ]:
delta_t = end_time - start_time
observe_time = start_time + delta_t * np.linspace(0, 1, 75)
# ### Stars ###
# In[ ]:
userEntered_list = list(objects.split(","))
target_list = userEntered_list
# In[ ]:
x = 0
for i in target_list:
target_list[x] = FixedTarget.from_name(target_list[x])
x += 1
# ### Airmass Curve ###
# In[ ]:
"""
plt.rcParams['font.family'] = "Times New Roman"
plt.rcParams['legend.loc'] = "Upper Right"
plt.rcParams['figure.dpi'] = 300
x = 0
for i in target_list:
plot_airmass(target_list[x], las, observe_time, max_airmass = 2.25, brightness_shading=True, altitude_yaxis=True)
x += 1
plt.legend(shadow=True, loc='center left', bbox_to_anchor=(1.1, 1))
plt.title('Airmass Curve for Night of ' + date)
plt.savefig('airmass.png', bbox_inches='tight', pad_inches=0.25)
"""
plt.rcParams['font.family'] = "Times New Roman"
plt.rcParams['legend.loc'] = "Upper Right"
plt.rcParams['figure.dpi'] = 300
x = 0
for i in target_list:
plot_airmass(target_list[x],
las,
observe_time,
max_airmass=2.25,
brightness_shading=True,
altitude_yaxis=True)
x += 1
plt.legend(shadow=True, loc='center left', bbox_to_anchor=(1.1, 1))
plt.title('Airmass Curve for Night of ' + date)
#os.remove("static/airmass.png") idk if necesarry
plt.savefig('static/data/airmass.png',
bbox_inches='tight',
pad_inches=0.25)
plt.clf()
def main():
#================ASKING HERE THE DETAILS OF YOUR OBSERVATION
name_of_the_observatory = str(
input("\nType the name of the observatory, e.g.: subaru : "))
name_timezone = str(input("Type the timezone e.g. US/Hawaii : "))
time_str = str(
input(
"Type the date and the time of observation e.g. 2000-06-30 23:30:00 : "
))
see_sun = str(input("Would you like to target the sun? [yes/no] "))
see_moon = str(input("Would you like to target the moon? [yes/no] "))
how_many_targets = int(
input("How many objects would you like to observe? "))
#/\ Here is in UTC
#IF YOU WANT TO PLOT THE MOON/SUN AIRMASS + MOON/SUN IN SKY
see_moon = 'yes'
see_sun = 'no'
observe_time = Time(time_str)
#time window
time = observe_time + np.linspace(-12, 12, 100) * u.hour
to_be_plot = time.plot_date
observer = observer_function(name_of_the_observatory, name_timezone)
i = 0
while how_many_targets > 0:
fig = plt.figure(figsize=(11, 7))
fig.subplots_adjust(hspace=0.5)
if see_sun == 'yes':
sun = targeting_sun(observe_time)
ax = plt.subplot(1, 2, 1)
plot_airmass(sun,
observer,
observe_time,
brightness_shading=True,
style_kwargs={'color': 'r'},
min_airmass=0.5,
max_airmass=3.5)
ax.set_title('Airmass')
plt.legend(shadow=True, loc=2)
ax = plt.subplot(1, 2, 2, projection='polar')
plot_sky(sun, observer, observe_time, style_kwargs={'color': 'r'})
ax.set_title('Position at time: ' + time_str + '[UTC]\n \n')
else:
pass
if see_moon == 'yes':
moon = targeting_moon(observe_time)
ax = plt.subplot(1, 2, 1)
plot_airmass(moon,
observer,
observe_time,
brightness_shading=True,
min_airmass=0.5,
max_airmass=3.5)
ax.set_title('Airmass')
plt.legend(shadow=True, loc=2)
ax = plt.subplot(1, 2, 2, projection='polar')
plot_sky(moon, observer, observe_time)
ax.set_title('Position at time: ' + time_str + '[UTC]\n \n')
else:
pass
#TARGET DATA
RA = str(input("Type the RA of your target e.g. 06h45m08.9173s : "))
DEC = str(input("Type the DEC of your target e.g. -16d42m58.017s : "))
NAME = str(input("Type the name of your target : "))
frame = str(input("Type the frame of your target e.g. icrs: "))
#frame = 'icrs'
target = target_wanted(RA, DEC, NAME)
ax = plt.subplot(1, 2, 1)
plot_airmass(target,
observer,
observe_time,
brightness_shading=True,
min_airmass=0.5,
max_airmass=3.5)
plt.text(0.5,
0.9,
'Observatory: ' + name_of_the_observatory + '\n Timezone: ' +
name_timezone,
horizontalalignment='center',
verticalalignment='center',
transform=ax.transAxes)
ax.set_title('Airmass')
plt.legend(shadow=True, loc=2)
ax = plt.subplot(1, 2, 2, projection='polar')
plot_sky(target, observer, observe_time)
ax.set_title('Position at time: ' + time_str + '[UTC]\n \n')
how_many_targets -= 1
i += 1
plt.legend(shadow=True, loc=2)
plt.tight_layout()
#CHANGE HERE THE PATH AND NAME YOUR DIRECTORY SHOULD BE SAVED IN/AS
plt.savefig('graph_representation/' + NAME + '.png')
def main():
#=================ADD HERE YOUR .TXT FILE WITH THE ID OF YOUR TARGETS
file_read = np.loadtxt('list_TIC_output.txt', skiprows=1)
ID_array = file_read[:, 0]
RA_array = file_read[:, 1]
DEC_array = file_read[:, 2]
#================ADD HERE THE DETAILS OF YOUR OBSERVATION
name_of_the_observatory = 'ctio'
name_timezone = 'America/Santiago'
time_str = '2019-07-25 04:00:00'
#/\ Here is in UTC
#IF YOU WANT TO PLOT THE MOON/SUN AIRMASS + MOON/SUN IN SKY
see_moon = 'yes'
see_sun = 'no'
how_many_targets = len(ID_array)
observe_time = Time(time_str)
#time window
time = observe_time + np.linspace(-12, 12, 100) * u.hour
to_be_plot = time.plot_date
observer = observer_function(name_of_the_observatory, name_timezone)
i = 0
while how_many_targets > 0:
fig = plt.figure(figsize=(11, 7))
fig.subplots_adjust(hspace=0.5)
if see_sun == 'yes':
sun = targeting_sun(observe_time)
ax = plt.subplot(1, 2, 1)
plot_airmass(sun,
observer,
observe_time,
brightness_shading=True,
style_kwargs={'color': 'r'},
min_airmass=0.5,
max_airmass=3.5)
ax.set_title('Airmass')
plt.legend(shadow=True, loc=2)
ax = plt.subplot(1, 2, 2, projection='polar')
plot_sky(sun, observer, observe_time, style_kwargs={'color': 'r'})
ax.set_title('Position at time: ' + time_str + '[UTC]\n \n')
else:
pass
if see_moon == 'yes':
moon = targeting_moon(observe_time)
ax = plt.subplot(1, 2, 1)
plot_airmass(moon,
observer,
observe_time,
brightness_shading=True,
min_airmass=0.5,
max_airmass=3.5)
ax.set_title('Airmass')
plt.legend(shadow=True, loc=2)
ax = plt.subplot(1, 2, 2, projection='polar')
plot_sky(moon, observer, observe_time)
ax.set_title('Position at time: ' + time_str + '[UTC]\n \n')
else:
pass
#TARGET DATA
RA = str(RA_array[i])
DEC = str(DEC_array[i])
NAME = str(int(ID_array[i]))
#frame = 'icrs'
target = target_wanted(RA, DEC, NAME)
ax = plt.subplot(1, 2, 1)
plot_airmass(target,
observer,
observe_time,
brightness_shading=True,
min_airmass=0.5,
max_airmass=3.5)
plt.text(0.5,
0.9,
'Observatory: ' + name_of_the_observatory + '\n Timezone: ' +
name_timezone,
horizontalalignment='center',
verticalalignment='center',
transform=ax.transAxes)
ax.set_title('Airmass')
plt.legend(shadow=True, loc=2)
ax = plt.subplot(1, 2, 2, projection='polar')
plot_sky(target, observer, observe_time)
ax.set_title('Position at time: ' + time_str + '[UTC]\n \n')
how_many_targets -= 1
i += 1
plt.legend(shadow=True, loc=2)
plt.tight_layout()
#CHANGE HERE THE PATH AND NAME YOUR DIRECTORY SHOULD BE SAVED IN/AS
plt.savefig('graph_representation/' + NAME + '.png')
def airmassplot(request, transient_id, obs_id, telescope_id):
import random
import django
import datetime
from astroplan.plots import plot_airmass
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
from matplotlib import rcParams
rcParams['figure.figsize'] = (7, 7)
transient = Transient.objects.get(pk=transient_id)
if int(obs_id):
obsnight = ClassicalObservingDate.objects.get(pk=obs_id)
obs_date = obsnight.obs_date
else:
obs_date = datetime.date.today() #time.now()
telescope = Telescope.objects.get(pk=telescope_id)
target = SkyCoord(transient.ra, transient.dec, unit=u.deg)
time = Time(str(obs_date).split('+')[0], format='iso')
location = EarthLocation.from_geodetic(telescope.longitude * u.deg,
telescope.latitude * u.deg,
telescope.elevation * u.m)
tel = Observer(location=location, name=telescope.name, timezone="UTC")
fig = Figure()
ax = fig.add_subplot(111)
canvas = FigureCanvas(fig)
ax.set_title("%s, %s, %s" %
(telescope.tostring(), transient.name, obs_date))
night_start = tel.twilight_evening_astronomical(time, which="previous")
night_end = tel.twilight_morning_astronomical(time, which="previous")
delta_t = night_end - night_start
observe_time = night_start + delta_t * np.linspace(0, 1, 75)
plot_airmass(target, tel, observe_time, ax=ax)
yr, mn, day, hr, minu, sec = night_start.iso.replace(':', ' ').replace(
'-', ' ').split()
starttime = datetime.datetime(int(yr), int(mn), int(day), int(hr),
int(minu))
if int(hr) == 0:
xlow = datetime.datetime(int(yr), int(mn), int(day) - 1, 23, int(minu))
else:
xlow = datetime.datetime(int(yr), int(mn), int(day),
int(hr) - 1, int(minu))
yr, mn, day, hr, minu, sec = night_end.iso.replace(':', ' ').replace(
'-', ' ').split()
endtime = datetime.datetime(int(yr), int(mn), int(day), int(hr), int(minu))
xhi = datetime.datetime(int(yr), int(mn), int(day), int(hr) + 1, int(minu))
ax.axvline(starttime, color='r',
label='18 deg twilight') #night_start.iso)
ax.axvline(endtime, color='r')
ax.legend(loc='lower right')
ax.set_xlim([xlow, xhi])
response = django.http.HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def plot_quadrature_windows(ra,
dec,
ticid,
t0,
period,
start_time,
end_time,
site,
obs_per_night=None,
N_points=500):
if (isinstance(ra, u.quantity.Quantity)
and isinstance(dec, u.quantity.Quantity)):
target_coord = SkyCoord(ra=ra, dec=dec)
elif (isinstance(ra, str) and isinstance(dec, str)):
target_coord = SkyCoord(ra=ra, dec=dec, unit=(u.hourangle, u.deg))
else:
raise NotImplementedError
target = FixedTarget(coord=target_coord, name='TIC' + ticid)
delta_t = end_time - start_time
observe_time = start_time + delta_t * np.linspace(0, 1, N_points)
fig = plt.figure(figsize=(24, 4))
ax = plt.gca()
plot_airmass(target, site, observe_time)
plt.plot_date(observe_time.plot_date, np.ones(len(observe_time)), alpha=0)
formatter = DateFormatter('%m/%d/%y')
ax.xaxis.set_major_formatter(formatter)
ax.xaxis.set_minor_locator(AutoMinorLocator())
ax.set_ylabel('Airmass', color='C0')
if not obs_per_night is None:
ix = 0
for o in obs_per_night:
if ix == 0:
ax.plot_date([o[0].plot_date, o[1].plot_date], [1.01, 1.01],
c='C2',
alpha=0.5,
zorder=2,
fmt='-',
lw=10,
label='06 to 10 UT')
else:
ax.plot_date([o[0].plot_date, o[1].plot_date], [1.01, 1.01],
c='C2',
alpha=0.5,
zorder=2,
fmt='-',
lw=10)
ix += 1
# calculate the expected RV signal. note we are ignoring barycentric timing
# effects (BJD vs JD), which are of order 16 minutes.
#
# note: it's cos, not sin. Eg., Eq 3 from Fulton+2018.
rv = np.cos(((2 * pi / period) * (observe_time.jd * u.day - t0)) * u.rad)
ax.legend(loc='best')
ax.get_xaxis().set_tick_params(which='both', direction='in')
ax2 = ax.twinx()
ax2.plot_date(observe_time.plot_date, rv, fmt='-', c='C1')
ax2.set_ylabel('RV', color='C1')
outpath = (os.path.join(OUTDIR, 'TIC{}.png'.format(ticid)))
fig.savefig(outpath, bbox_inches='tight')
print('made {}'.format(outpath))
kmtnet_styles = {
'linestyle': '-',
'color': 'g',
'alpha': 0.9,
'linewidth': 2.9
}
#meerkat_styles = {'linestyle': '-', 'color': 'b', 'alpha': 0.9, 'linewidth': 2.9 }
askap_styles = {
'linestyle': '-',
'color': '#F39C12',
'alpha': 0.9,
'linewidth': 2.9
}
#Plotting airmasses
plot_airmass(hydraA4, telescope, date_range, style_kwargs=observatory1_styles)
plot_airmass(hydraA2, ctio, date_range, style_kwargs=ctio_styles)
plot_airmass(hydraA3, kmtnet, date_range, style_kwargs=kmtnet_styles)
plot_airmass(hydraA5, askap, date_range, style_kwargs=askap_styles)
plt.title('AIRMASSES AT' + ' ' + Observatory_name + ' ' + ctio.name.upper() +
' ' + askap.name + ' ' + 'KmtNeT Telescope/Observatory',
fontsize=30)
plt.xlabel('TIMES', fontsize=20)
plt.xticks(fontsize=20)
plt.ylabel('AIRMASSES', fontsize=20)
plt.yticks(fontsize=20)
plt.legend(shadow=True, loc=1, prop={'size': 12})
trunctable = objtab['OBJ', 'RA', 'Dec']
trunctable.pprint(max_lines=-1, max_width=-1)
# In[17]:
plt.clf()
for line in trunctable:
cur_targ = FixedTarget(name=line['OBJ'],
coord=SkyCoord(line['RA'],
line['Dec'],
frame='icrs'))
if line == trunctable[0]:
plot_airmass(cur_targ,
observatory,
daytime,
brightness_shading=True,
altitude_yaxis=True)
else:
plot_airmass(cur_targ,
observatory,
daytime,
brightness_shading=False,
altitude_yaxis=False)
plt.savefig((subdir + '\\amassplot.png'),
dpi=900,
orientation='landscape',
bbox_inches='tight')
plt.clf()
# In[18]:
from astroplan import Observer
from astropy.time import Time
from astropy.coordinates import SkyCoord
from astroplan import FixedTarget
from astroplan.plots import plot_airmass
from astroplan.plots import plot_sky
import numpy as np
latitude = '+40d45m31.3236s'
longitude = '-111d52m34.2588s'
elevation = 1288 * u.m
location = EarthLocation.from_geodetic(longitude, latitude, elevation)
slc = Observer(name='SLC', location=location, timezone=timezone('US/Mountain'))
time = Time('2020-01-18 03:00:00')
betelgeuse = FixedTarget.from_name('Betelgeuse')
sirius = FixedTarget.from_name('Sirius')
plot_airmass(betelgeuse,
slc,
time,
brightness_shading=True,
altitude_yaxis=True)
plot_airmass(sirius, slc, time, brightness_shading=True, altitude_yaxis=True)
plt.show()
manytimes = time + np.linspace(-3, 9, 13) * u.hour
plot_sky(betelgeuse, slc, manytimes, north_to_east_ccw=False)
plot_sky(sirius, slc, manytimes, north_to_east_ccw=False)
plt.show()
def create_observation_observables(object_id,
object_dir,
since,
name,
epoch,
epoch_low_err,
epoch_up_err,
period,
period_low_err,
period_up_err,
duration,
observatories_file,
timezone,
latitude,
longitude,
altitude,
max_days,
min_altitude,
moon_min_dist,
moon_max_dist,
transit_fraction,
baseline,
error_alert=True):
"""
@param object_id: the candidate id
@param object_dir: the candidate directory
@param since: starting plan date
@param name: the name given to the candidate
@param epoch: the candidate epoch
@param epoch_low_err: the candidate epoch's lower error
@param epoch_up_err: the candidate epoch's upper error
@param period: the candidate period
@param period_low_err: the candidate period's lower error
@param period_up_err: the candidate period's upper error
@param duration: the candidate duration
@param observatories_file: the file containing the observatories file (csv format)
@param timezone: the timezone of the observatory (if observatories_file=None)
@param latitude: the latitude of the observatory (if observatories_file=None)
@param longitude: the longitude of the observatory (if observatories_file=None)
@param altitude: the altitude of the observatory (if observatories_file=None)
@param max_days: the maximum number of days to compute the observables
@param min_altitude: the minimum altitude of the target above the horizon
@param moon_min_dist: the minimum moon distance for moon illumination = 0
@param moon_max_dist: the minimum moon distance for moon illumination = 1
@param transit_fraction: the minimum transit observability (0.25 for at least ingress/egress, 0.5 for ingress/egress
+ midtime, 1 for ingress, egress and midtime).
@param baseline: the required baseline in hours.
@param: error_alert: whether to create the alert date to signal imprecise observations
@return: the generated data and target folders
"""
if observatories_file is not None:
observatories_df = pd.read_csv(observatories_file, comment='#')
else:
observatories_df = pd.DataFrame(
columns=['name', 'tz', 'lat', 'long', 'alt'])
observatories_df = observatories_df.append("Obs-1", timezone, latitude,
longitude, altitude)
# TODO probably convert epoch to proper JD
mission, mission_prefix, id_int = LcBuilder().parse_object_info(object_id)
if mission == "TESS":
primary_eclipse_time = Time(epoch, format='btjd', scale="tdb")
elif mission == "Kepler" or mission == "K2":
primary_eclipse_time = Time(epoch, format='bkjd', scale="tdb")
else:
primary_eclipse_time = Time(epoch, format='jd')
target = FixedTarget(SkyCoord(coords, unit=(u.deg, u.deg)))
n_transits = int(max_days // period)
system = EclipsingSystem(primary_eclipse_time=primary_eclipse_time,
orbital_period=u.Quantity(period, unit="d"),
duration=u.Quantity(duration, unit="h"),
name=name)
observables_df = pd.DataFrame(columns=[
'observatory', 'timezone', 'start_obs', 'end_obs', 'ingress', 'egress',
'midtime', "midtime_up_err_h", "midtime_low_err_h", 'twilight_evening',
'twilight_morning', 'observable', 'moon_phase', 'moon_dist'
])
plan_dir = object_dir + "/plan"
images_dir = plan_dir + "/images"
if os.path.exists(plan_dir):
shutil.rmtree(plan_dir, ignore_errors=True)
os.mkdir(plan_dir)
if os.path.exists(images_dir):
shutil.rmtree(images_dir, ignore_errors=True)
os.mkdir(images_dir)
alert_date = None
for index, observatory_row in observatories_df.iterrows():
observer_site = Observer(latitude=observatory_row["lat"],
longitude=observatory_row["lon"],
elevation=u.Quantity(observatory_row["alt"],
unit="m"))
midtransit_times = system.next_primary_eclipse_time(
since, n_eclipses=n_transits)
ingress_egress_times = system.next_primary_ingress_egress_time(
since, n_eclipses=n_transits)
constraints = [
AtNightConstraint.twilight_nautical(),
AltitudeConstraint(min=min_altitude * u.deg),
MoonIlluminationSeparationConstraint(
min_dist=moon_min_dist * u.deg, max_dist=moon_max_dist * u.deg)
]
moon_for_midtransit_times = get_moon(midtransit_times)
moon_dist_midtransit_times = moon_for_midtransit_times.separation(
SkyCoord(star_df.iloc[0]["ra"], star_df.iloc[0]["dec"],
unit="deg"))
moon_phase_midtransit_times = np.round(
astroplan.moon_illumination(midtransit_times), 2)
transits_since_epoch = np.round(
(midtransit_times - primary_eclipse_time).jd / period)
midtransit_time_low_err = np.round(
(((transits_since_epoch * period_low_err)**2 + epoch_low_err**2)
**(1 / 2)) * 24, 2)
midtransit_time_up_err = np.round(
(((transits_since_epoch * period_up_err)**2 + epoch_up_err**2)
**(1 / 2)) * 24, 2)
low_err_delta = TimeDelta(midtransit_time_low_err * 3600, format='sec')
up_err_delta = TimeDelta(midtransit_time_up_err * 3600, format='sec')
i = 0
for midtransit_time in midtransit_times:
twilight_evening = observer_site.twilight_evening_nautical(
midtransit_time)
twilight_morning = observer_site.twilight_morning_nautical(
midtransit_time)
ingress = ingress_egress_times[i][0]
egress = ingress_egress_times[i][1]
lowest_ingress = ingress - low_err_delta[i]
highest_egress = egress + up_err_delta[i]
if error_alert and (highest_egress - lowest_ingress).jd > 0.33:
alert_date = midtransit_time if (alert_date is None) or (
alert_date is not None
and alert_date >= midtransit_time) else alert_date
break
else:
baseline_low = lowest_ingress - baseline * u.hour
baseline_up = highest_egress + baseline * u.hour
transit_times = baseline_low + (
baseline_up - baseline_low) * np.linspace(0, 1, 100)
observable_transit_times = astroplan.is_event_observable(
constraints, observer_site, target, times=transit_times)[0]
observable_transit_times_true = np.argwhere(
observable_transit_times)
observable = len(observable_transit_times_true) / 100
if observable < transit_fraction:
i = i + 1
continue
start_obs = transit_times[observable_transit_times_true[0]][0]
end_obs = transit_times[observable_transit_times_true[
len(observable_transit_times_true) - 1]][0]
start_plot = baseline_low
end_plot = baseline_up
if twilight_evening > start_obs:
start_obs = twilight_evening
if twilight_morning < end_obs:
end_obs = twilight_morning
moon_dist = round(moon_dist_midtransit_times[i].degree)
moon_phase = moon_phase_midtransit_times[i]
# TODO get is_event_observable for several parts of the transit (ideally each 5 mins) to get the proper observable percent. Also with baseline
if observatory_row["tz"] is not None and not np.isnan(
observatory_row["tz"]):
observer_timezone = observatory_row["tz"]
else:
observer_timezone = get_offset(observatory_row["lat"],
observatory_row["lon"],
midtransit_time.datetime)
observables_df = observables_df.append(
{
"observatory":
observatory_row["name"],
"timezone":
observer_timezone,
"ingress":
ingress.isot,
"start_obs":
start_obs.isot,
"end_obs":
end_obs.isot,
"egress":
egress.isot,
"midtime":
midtransit_time.isot,
"midtime_up_err_h":
str(int(midtransit_time_up_err[i] // 1)) + ":" +
str(int(midtransit_time_up_err[i] % 1 * 60)).zfill(2),
"midtime_low_err_h":
str(int(midtransit_time_low_err[i] // 1)) + ":" +
str(int(midtransit_time_low_err[i] % 1 * 60)).zfill(2),
"twilight_evening":
twilight_evening.isot,
"twilight_morning":
twilight_morning.isot,
"observable":
observable,
"moon_phase":
moon_phase,
"moon_dist":
moon_dist
},
ignore_index=True)
plot_time = start_plot + (end_plot - start_plot) * np.linspace(
0, 1, 100)
plt.tick_params(labelsize=6)
airmass_ax = plot_airmass(target,
observer_site,
plot_time,
brightness_shading=False,
altitude_yaxis=True)
airmass_ax.axvspan(twilight_morning.plot_date,
end_plot.plot_date,
color='white')
airmass_ax.axvspan(start_plot.plot_date,
twilight_evening.plot_date,
color='white')
airmass_ax.axvspan(twilight_evening.plot_date,
twilight_morning.plot_date,
color='gray')
airmass_ax.axhspan(1. / np.cos(np.radians(90 - min_altitude)),
5.0,
color='green')
airmass_ax.get_figure().gca().set_title("")
airmass_ax.get_figure().gca().set_xlabel("")
airmass_ax.get_figure().gca().set_ylabel("")
airmass_ax.set_xlabel("")
airmass_ax.set_ylabel("")
xticks = []
xticks_labels = []
xticks.append(start_obs.plot_date)
hour_min_sec_arr = start_obs.isot.split("T")[1].split(":")
xticks_labels.append("T1_" + hour_min_sec_arr[0] + ":" +
hour_min_sec_arr[1])
plt.axvline(x=start_obs.plot_date, color="violet")
xticks.append(end_obs.plot_date)
hour_min_sec_arr = end_obs.isot.split("T")[1].split(":")
xticks_labels.append("T1_" + hour_min_sec_arr[0] + ":" +
hour_min_sec_arr[1])
plt.axvline(x=end_obs.plot_date, color="violet")
if start_plot < lowest_ingress < end_plot:
xticks.append(lowest_ingress.plot_date)
hour_min_sec_arr = lowest_ingress.isot.split("T")[1].split(":")
xticks_labels.append("T1_" + hour_min_sec_arr[0] + ":" +
hour_min_sec_arr[1])
plt.axvline(x=lowest_ingress.plot_date, color="red")
if start_plot < ingress < end_plot:
xticks.append(ingress.plot_date)
hour_min_sec_arr = ingress.isot.split("T")[1].split(":")
xticks_labels.append("T1_" + hour_min_sec_arr[0] + ":" +
hour_min_sec_arr[1])
plt.axvline(x=ingress.plot_date, color="orange")
if start_plot < midtransit_time < end_plot:
xticks.append(midtransit_time.plot_date)
hour_min_sec_arr = midtransit_time.isot.split("T")[1].split(
":")
xticks_labels.append("T0_" + hour_min_sec_arr[0] + ":" +
hour_min_sec_arr[1])
plt.axvline(x=midtransit_time.plot_date, color="black")
if start_plot < egress < end_plot:
xticks.append(egress.plot_date)
hour_min_sec_arr = egress.isot.split("T")[1].split(":")
xticks_labels.append("T4_" + hour_min_sec_arr[0] + ":" +
hour_min_sec_arr[1])
plt.axvline(x=egress.plot_date, color="orange")
if start_plot < highest_egress < end_plot:
xticks.append(highest_egress.plot_date)
hour_min_sec_arr = highest_egress.isot.split("T")[1].split(":")
xticks_labels.append("T4_" + hour_min_sec_arr[0] + ":" +
hour_min_sec_arr[1])
plt.axvline(x=highest_egress.plot_date, color="red")
airmass_ax.xaxis.set_tick_params(labelsize=5)
airmass_ax.set_xticks([])
airmass_ax.set_xticklabels([])
degrees_ax = get_twin(airmass_ax)
degrees_ax.yaxis.set_tick_params(labelsize=6)
degrees_ax.set_yticks([1., 1.55572383, 2.])
degrees_ax.set_yticklabels([90, 50, 30])
fig = matplotlib.pyplot.gcf()
fig.set_size_inches(1.25, 0.75)
plt.savefig(plan_dir + "/images/" + observatory_row["name"] + "_" +
str(midtransit_time.isot)[:-4] + ".png",
bbox_inches='tight')
plt.close()
i = i + 1
observables_df = observables_df.sort_values(["midtime", "observatory"],
ascending=True)
observables_df.to_csv(plan_dir + "/observation_plan.csv", index=False)
print("Observation plan created in directory: " + object_dir)
return observatories_df, observables_df, alert_date, plan_dir, images_dir
plt.ylabel('Gaia G absolute magnitude')
plt.ylim([-5, 10])
plt.gca().invert_yaxis()
plotName = outfile.replace(".dat", "_hr.png").replace(".txt", "_hr.png")
plt.savefig(plotName)
plt.close()
table = observability_table(global_constraints,
kp,
FixedTargets,
time_range=[tstart, tend])
idx = np.where(table["ever observable"])[0]
print("%d/%d targets observable from %s-%s" %
(len(idx), len(table), tstart, tend))
FixedTargets = [FixedTargets[i] for i in idx]
plt.figure(figsize=(30, 20))
ax = plot_airmass(FixedTargets, kp, observe_time, brightness_shading=True)
plt.legend(shadow=True, loc=2)
altitude_ticks = np.array([90, 60, 50, 40, 30, 20])
airmass_ticks = 1. / np.cos(np.radians(90 - altitude_ticks))
ax2 = ax.twinx()
ax2.invert_yaxis()
ax2.set_yticks(airmass_ticks)
ax2.set_yticklabels(altitude_ticks)
ax2.set_ylim(ax.get_ylim())
ax2.set_ylabel('Altitude [degrees]')
plotName = outfile.replace(".dat", ".png").replace(".txt", ".png")
plt.savefig(plotName)
plt.close()
def main(args=None):
p = parser()
opts = p.parse_args(args)
# Late imports
import operator
import sys
from astroplan import Observer
from astroplan.plots import plot_airmass
from astropy.coordinates import EarthLocation, SkyCoord
from astropy.table import Table
from astropy.time import Time
from astropy import units as u
from matplotlib import dates
from matplotlib.cm import ScalarMappable
from matplotlib.colors import Normalize
from matplotlib.patches import Patch
from matplotlib import pyplot as plt
from tqdm import tqdm
import pytz
from ..io import fits
from .. import moc
from .. import plot # noqa
from ..extern.quantile import percentile
if opts.site is None:
if opts.site_longitude is None or opts.site_latitude is None:
p.error('must specify either --site or both '
'--site-longitude and --site-latitude')
location = EarthLocation(lon=opts.site_longitude * u.deg,
lat=opts.site_latitude * u.deg,
height=(opts.site_height or 0) * u.m)
if opts.site_timezone is not None:
location.info.meta = {'timezone': opts.site_timezone}
observer = Observer(location)
else:
if not ((opts.site_longitude is None) and
(opts.site_latitude is None) and (opts.site_height is None) and
(opts.site_timezone is None)):
p.error('argument --site not allowed with arguments '
'--site-longitude, --site-latitude, '
'--site-height, or --site-timezone')
observer = Observer.at_site(opts.site)
m = fits.read_sky_map(opts.input.name, moc=True)
# Make an empty airmass chart.
t0 = Time(opts.time) if opts.time is not None else Time.now()
t0 = observer.midnight(t0)
ax = plot_airmass([], observer, t0, altitude_yaxis=True)
# Remove the fake source and determine times that were used for the plot.
del ax.lines[:]
times = Time(np.linspace(*ax.get_xlim()), format='plot_date')
theta, phi = moc.uniq2ang(m['UNIQ'])
coords = SkyCoord(phi, 0.5 * np.pi - theta, unit='rad')
prob = moc.uniq2pixarea(m['UNIQ']) * m['PROBDENSITY']
levels = np.arange(90, 0, -10)
nlevels = len(levels)
percentiles = np.concatenate((50 - 0.5 * levels, 50 + 0.5 * levels))
airmass = np.column_stack([
percentile(condition_secz(coords.transform_to(observer.altaz(t)).secz),
percentiles,
weights=prob) for t in tqdm(times)
])
cmap = ScalarMappable(Normalize(0, 100), plt.get_cmap())
for level, lo, hi in zip(levels, airmass[:nlevels], airmass[nlevels:]):
ax.fill_between(
times.plot_date,
clip_verylarge(lo), # Clip infinities to large but finite values
clip_verylarge(hi), # because fill_between cannot handle inf
color=cmap.to_rgba(level),
zorder=2)
ax.legend([Patch(facecolor=cmap.to_rgba(level)) for level in levels],
['{}%'.format(level) for level in levels])
# ax.set_title('{} from {}'.format(m.meta['objid'], observer.name))
# Adapted from astroplan
start = times[0]
twilights = [
(times[0].datetime, 0.0),
(observer.sun_set_time(Time(start), which='next').datetime, 0.0),
(observer.twilight_evening_civil(Time(start),
which='next').datetime, 0.1),
(observer.twilight_evening_nautical(Time(start),
which='next').datetime, 0.2),
(observer.twilight_evening_astronomical(Time(start),
which='next').datetime, 0.3),
(observer.twilight_morning_astronomical(Time(start),
which='next').datetime, 0.4),
(observer.twilight_morning_nautical(Time(start),
which='next').datetime, 0.3),
(observer.twilight_morning_civil(Time(start),
which='next').datetime, 0.2),
(observer.sun_rise_time(Time(start), which='next').datetime, 0.1),
(times[-1].datetime, 0.0),
]
twilights.sort(key=operator.itemgetter(0))
for i, twi in enumerate(twilights[1:], 1):
if twi[1] != 0:
ax.axvspan(twilights[i - 1][0],
twilights[i][0],
ymin=0,
ymax=1,
color='grey',
alpha=twi[1],
linewidth=0)
if twi[1] != 0.4:
ax.axvspan(twilights[i - 1][0],
twilights[i][0],
ymin=0,
ymax=1,
color='white',
alpha=0.8 - 2 * twi[1],
zorder=3,
linewidth=0)
# Add local time axis
timezone = (observer.location.info.meta or {}).get('timezone')
if timezone:
tzinfo = pytz.timezone(timezone)
ax2 = ax.twiny()
ax2.set_xlim(ax.get_xlim())
ax2.set_xticks(ax.get_xticks())
ax2.xaxis.set_major_formatter(dates.DateFormatter('%H:%M', tz=tzinfo))
plt.setp(ax2.get_xticklabels(), rotation=-30, ha='right')
ax2.set_xlabel("Time from {} [{}]".format(
min(times).to_datetime(tzinfo).date(), timezone))
if opts.verbose:
# Write airmass table to stdout.
times.format = 'isot'
table = Table(masked=True)
table['time'] = times
table['sun_alt'] = np.ma.masked_greater_equal(
observer.sun_altaz(times).alt, 0)
table['sun_alt'].format = lambda x: '{}'.format(int(np.round(x)))
for p, data in sorted(zip(percentiles, airmass)):
table[str(p)] = np.ma.masked_invalid(data)
table[str(p)].format = lambda x: '{:.01f}'.format(np.around(x, 1))
table.write(sys.stdout, format='ascii.fixed_width')
# Show or save output.
opts.output()
################################################################################
--------------------------------------------------------------------------------
################################################################################
'''
print('Please note this code is very much a work in progress')
# Defining location of observatory
loc = EarthLocation.from_geodetic(-73.751433 * u.deg, 42.719546 * u.deg,
106 * u.m)
Breyo = Observer(location=loc, name="Breyo", timezone="US/Eastern")
# Defining time of observation
obsDate = input('Date of Observation run [yyyy-mm-dd]:')
obsTime = input('Time of Observation in military [hh:mm:ss]:')
obsDateTime = obsDate + ' ' + obsTime
print(obsDateTime)
# Target info
targetname = input('Name of the target:')
tra = float(input('Target RA in degrees:'))
tdec = float(input('Target DEC in degrees:'))
center_coord = SkyCoord(ra=tra * u.deg, dec=tdec * u.deg)
center = FixedTarget(coord=center_coord, name=targetname)
plot_airmass(center,
Breyo,
obsDateTime,
brightness_shading=True,
altitude_yaxis=True)
plt.show()
def observe(request, method="POST"):
if request.POST['observing_date'] == "":
messages.error(request, 'Please choose a date!')
if request.POST['name'] == "":
messages.error(request, 'Object name cannot be empty!')
if request.POST['ra'] == "":
messages.error(request, 'Object RA cannot be empty!')
if request.POST['dec'] == "":
messages.error(request, 'Object Dec cannot be empty!')
if request.POST['observing_date'] == "" or request.POST[
'name'] == "" or request.POST['ra'] == "" or request.POST[
'dec'] == "":
return redirect('/')
observatory = None
offset = None
for idx, val in enumerate(T['name']):
if val == request.POST['observatory']:
observatory = Observer(longitude=T['longitude'][idx] * u.deg,
latitude=T['latitude'][idx] * u.deg,
elevation=T['altitude'][idx] * u.m,
name=T['name'][idx])
today = datetime.now()
if tf.certain_timezone_at(lat=T['latitude'][idx],
lng=T['longitude'][idx]) == None:
return redirect('/error')
tz_target = timezone(
tf.certain_timezone_at(lat=T['latitude'][idx],
lng=T['longitude'][idx]))
# ATTENTION: tf.certain_timezone_at(...) could be None! handle error case
today_target = tz_target.localize(today)
today_utc = utc.localize(today)
offset = (today_utc - today_target).total_seconds() * u.s
# # offset = offsetfunction(observatory)
observe_date = Time(request.POST['observing_date'] + ' 00:00:00',
format='iso')
sunset_here = observatory.sun_set_time(observe_date,
which="nearest") + offset
sunrise_here = observatory.sun_rise_time(observe_date,
which="next") + offset
midnight_here = observatory.midnight(observe_date,
which="nearest") + offset
astro_set = observatory.twilight_evening_astronomical(observe_date,
which='nearest')
astro_rise = observatory.twilight_morning_astronomical(observe_date,
which='next')
coords = SkyCoord(request.POST['ra'], request.POST['dec'], frame='icrs')
target = FixedTarget(name=request.POST['name'], coord=coords)
start_time = astro_set
end_time = astro_rise
delta_t = end_time - start_time
observe_time = start_time + delta_t * np.linspace(0.0, 2.0, 100)
plt.ioff()
sky = plot_sky(target, observatory, observe_time)
sky.figure.savefig('apps/project_app/static/project_app/plot_sky.png')
plt.close()
plt.ioff()
airmass = plot_airmass(target, observatory, observe_time)
airmass.figure.savefig(
'apps/project_app/static/project_app/plot_airmass.png')
plt.close()
plt.ioff()
finder_image = plot_finder_image(target)
finder_image[0].figure.savefig(
'apps/project_app/static/project_app/plot_finder_image.png')
plt.close()
request.session['context'] = {
"sunset": Time(sunset_here, format="iso").value,
"sunrise": Time(sunrise_here, format="iso").value,
"date": Time(observe_date, format="iso").value,
"midnight": Time(midnight_here, format="iso").value,
"site": request.POST['observatory'],
"ra": request.POST['ra'],
"dec": request.POST['dec'],
"name": request.POST['name']
}
return redirect('/display')
def airmass():
plot_airmass(altair, subaru, time)
plot_airmass(vega, subaru, time)
plt.legend(loc=1, bbox_to_anchor=(1, 1))
plt.show()
object_set = site.target_set_time(time, obj) - 5 * u.minute
from astroplan import download_IERS_A
download_IERS_A()
sunset_tonight = site.sun_set_time(time, which='nearest')
if sunset_tonight < time:
print("the sun has already set at this location")
else:
print("sunset at your selected site will be " + sunset_tonight.iso +
" UTC")
t.sleep(3)
from astroplan.plots import plot_airmass
import matplotlib.pyplot as plt
plot_airmass(obj, site, time)
plt.title("Visibility Chart")
plt.legend(loc=1, bbox_to_anchor=(1, 1))
plt.show()
t.sleep(3)
site.altaz(time, obj).secz
from astroplan.plots import plot_parallactic
plot_parallactic(obj, site, time)
plt.legend(loc=2)
plt.show()
t.sleep(3)
moon_rise = site.moon_rise_time(time)
moon_set = site.moon_set_time(time)
print("Moon rise will be at: " + str(moon_rise))
def observability(cand=[],
site='VLT',
time=['2017-09-01T00:00:00.00', '2018-03-01T00:00:00.00'],
airmass=1.3):
"""
cand is class object with parameters: name, ra, dec
"""
# set observation site
if site == 'VLT':
if 0:
longitude = '-70d24m12.000s'
latitude = '-24d37m34.000s'
elevation = 2635 * u.m
vlt = EarthLocation.from_geodetic(longitude, latitude, elevation)
observer = astroplan.Observer(
name='VLT',
location=vlt,
pressure=0.750 * u.bar,
relative_humidity=0.11,
temperature=0 * u.deg_C,
timezone=timezone('America/Santiago'),
description="Very Large Telescope, Cerro Paranal")
eso = astroplan.Observer.at_site('eso')
else:
observer = Observer.at_site('Cerro Paranal')
if site == 'MagE':
observer = Observer.at_site('las campanas observatory')
if site == 'keck':
observer = Observer.at_site('keck')
print(observer)
# set time range constrains
if isinstance(time, str):
# all year
if len(time) == 4:
timerange = 'period'
time_range = Time(time + "-01-01T00:00:00.00",
time + "-12-31T23:59:00.00")
else:
timerange = 'onenight'
time = Time(time)
elif isinstance(time, list):
if len(time) == 2:
timerange = 'period'
print(Time(['2017-01-03']), time)
time_range = Time(time)
else:
timerange = 'onenight'
time = Time(time[0])
if timerange == 'onenight':
# calculate sunset and sunrise
sunset = observer.sun_set_time(time, which='nearest')
print('Sunset at ', sunset.iso)
sunrise = observer.sun_rise_time(time, which='nearest')
print('Sunrise at ', sunrise.iso)
time_range = Time([sunset, sunrise])
# set time array during the night
time = time_range[0] + (time_range[1] - time_range[0]) * np.linspace(
0, 1, 55)
print(time)
# set visibility constrains
# constraints = [AirmassConstraint(1.5), AtNightConstraint.twilight_civil()]
print(airmass)
constraints = [
AirmassConstraint(airmass),
AtNightConstraint.twilight_civil()
]
# set parameters of calculations
read_vis = 0
if read_vis == 0:
f_vis = open('DR12_cand_vis_temp.dat', 'w')
month_detalied = 1
show_moon = 0
airmass_plot = 0
sky_plot = 0
if airmass_plot == 1:
f, ax_air = plt.subplots()
if sky_plot == 1:
f, ax_sky = plt.subplots()
targets = []
if show_moon == 1:
print(observer.moon_altaz(time).alt)
print(observer.moon_altaz(time).az)
# moon = SkyCoord(alt = observer.moon_altaz(time).alt, az = observer.moon_altaz(time).az, obstime = time, frame = 'altaz', location = observer.location)
# print(moon.icrs)
for i, can in enumerate(cand):
print(can.name)
# calculate target coordinates
coordinates = SkyCoord(float(can.ra) * u.deg,
float(can.dec) * u.deg,
frame='icrs')
#print(can.ra, can.dec)
#print(coordinates.to_string('hmsdms'))
target = FixedTarget(name=can.name, coord=coordinates)
targets.append(target)
# print(observer.target_is_up(time, targets[i]))
# calculate airmass
if timerange == 'onenight':
if sky_plot == 1:
plot_sky(target, observer, time)
airmass = observer.altaz(time, target).secz
if airmass_plot == 1:
plot_airmass(target, observer, time, ax=ax)
air_min = 1000
k_min = -1
for k, a in enumerate(airmass):
if 0 < a < air_min:
air_min = a
k_min = k
print(air_min, time[k_min].iso)
if k_min > -1 and show_moon == 1:
moon = SkyCoord(alt=observer.moon_altaz(time[k_min]).alt,
az=observer.moon_altaz(time[k_min]).az,
obstime=time[k_min],
frame='altaz',
location=observer.location)
can.moon_sep = Angle(moon.separation(
target.coord)).to_string(fields=1)
print(can.moon_sep)
can.airmass = air_min
can.time = time[k_min].iso
# ever_observable = astroplan.is_observable(constraints, observer, targets, time_range=time_range)
# print(ever_observable)
if month_detalied == 1:
tim = []
months = [
'2017-10-01', '2017-11-01', '2017-12-01', '2018-01-01',
'2018-02-01', '2018-03-01', '2018-04-01'
]
#for l in range(int(str(time_range[0])[5:7]), int(str(time_range[1])[5:7]) + 1):
for l in range(len(months) - 1):
if 0:
start = "2017-" + "{0:0>2}".format(l) + "-01T00:00"
end = "2017-" + "{0:0>2}".format(l + 1) + "-01T00:00"
if l == 12:
end = "2018-01-01T00:00"
else:
start = months[l]
end = months[l + 1]
time_range_temp = Time([start, end])
table = astroplan.observability_table(
constraints,
observer, [target],
time_range=time_range_temp)
tim.append(table[0][3])
# print(tim, max(tim), tim.index(max(tim)))
print(tim)
can.time = max(tim)
if max(tim) != 0:
if 0:
can.month = str(calendar.month_name[tim.index(max(tim)) +
1])[:3]
else:
can.month = tim.index(max(tim))
can.up = 'True'
else:
can.up = 'False'
can.month = '---'
print(can.up, can.month, can.time)
if month_detalied == 0:
table = astroplan.observability_table(constraints,
observer,
targets,
time_range=time_range)
print(table)
for i, can in enumerate(cand):
can.up = table[i][1]
can.time = table[i][3]
# print(table[k][0], table[k][1], table[k][2], table[k][3])
#table.write('DR12_candidates_obs.dat', format='ascii')
# f_out.write(table)
if sky_plot == 1:
plt.legend(loc='center left', bbox_to_anchor=(1.25, 0.5))
plt.show()
# Object rise / set
star_rise = obs.target_rise_time(now, star)
star_set = obs.target_set_time(now, star)
print(star_name, "rise time", star_rise.iso)
print(star_name, "set time", star_set.iso)
# Observation window
start = np.max([sunset_tonight, star_rise])
end = np.min([sunrise_tomorrow, star_set])
print(star_name, "obs_start", start.iso)
print(star_name, "obs_end ", end.iso)
# Make Plot of airmass vs time.
fig, ax = plt.subplots()
# Time array for sunset to sunrise
times = sunset_tonight + np.linspace(0, night_length_h, 100) * u.hour
etwil = sunset_tonight + 0.5 * u.hour * np.ones(2)
mtwil = sunrise_tomorrow - 0.5 * u.hour * np.ones(2)
plot_airmass(star, obs, times, ax=ax, max_airmass=2.5)
plot_airmass(star2, obs, times, ax=ax, max_airmass=2.5)
plt.legend(shadow=True)
ax.plot_date(etwil.plot_date, [1.0, 2.5], 'red',
alpha=0.5) # sunset plus 1/2 hour
ax.plot_date(mtwil.plot_date, [1.0, 2.5], 'red', alpha=0.5)
plt.show()
from astroplan.plots import plot_airmass
subaru = Observer.at_site('subaru')
altair = FixedTarget.from_name('Altair')
vega = FixedTarget.from_name('Vega')
coordinates = SkyCoord('20h41m25.9s', '+45d16m49.3s', frame='icrs')
deneb = FixedTarget(name='Deneb', coord=coordinates)
time = Time('2015-06-16 12:00:00')
sunset_tonight = subaru.sun_set_time(time, which='nearest')
sunrise_tonight = subaru.sun_rise_time(time, which='nearest')
# Are our targets up at the appropriate time?
subaru.target_is_up(time, altair)
subaru.target_is_up(time, vega)
subaru.is_night(time)
# What are optimal observation times, in terms of air mass?
altair_rise = subaru.target_rise_time(time, altair) + 5*u.minute
altair_set = subaru.target_set_time(time, altair) - 5*u.minute
plot_airmass(altair, subaru, time)
plot_airmass(vega, subaru, time)
plot_airmass(deneb, subaru, time)
plt.legend(loc=1, bbox_to_anchor=(1, 1))
plt.savefig('stars_vs_airmass.png', dpi=200)
