def observability_objects(data):
"""
Test the observability of a list of objects for a single date
Parameters
----------
data : POST data format
data = {
'observatory' : 'OT',
'altitude_lower_limit' : '30',
'altitude_higher_limit' : '90',
'objects' : [{
'name' : 'Kelt 8b',
'RA' : 283.30551667 ,
'Dec' : 24.12738139,
'dates' : [
['2020-06-11 00:16:30', '2020-06-11 03:44:26'],
['2020-06-14 06:07:56', '2020-06-14 09:35:53']
]
},
{
'name' : 'TIC 123456789',
'RA' : 13.13055667 ,
'Dec' : 24.13912738,
'dates' : [
['2020-06-11 23:59:59']
]
}
]
}
Returns
-------
observability : dict
Dictionary with the observability and moon distance for all objects
{'V0879 Cas' : {
'observability' : 'True', 'moon_separation' : 30.4
},
'RU Scl' : {
'observability' : 'True', 'moon_separation' : 10.8
}
}
"""
import astropy.units as u
from astroplan import FixedTarget
from astroplan import (AltitudeConstraint, AtNightConstraint)
from astroplan import is_observable, is_always_observable
# Site location
location = get_location(data['observatory'])
# dict of observability for each target
observabilities = {}
if 'twilight_type' not in data.keys():
data['twilight_type'] = 'astronomical'
if data['twilight_type'] == 'civil':
twilight_constraint = AtNightConstraint.twilight_civil()
elif data['twilight_type'] == 'nautical':
twilight_constraint = AtNightConstraint.twilight_nautical()
else:
twilight_constraint = AtNightConstraint.twilight_astronomical()
# Observation constraints
constraints = [
AltitudeConstraint(
float(data['altitude_lower_limit']) * u.deg,
float(data['altitude_higher_limit']) * u.deg), twilight_constraint
]
for target in data['objects']:
coords = SkyCoord(ra=target['RA'] * u.deg, dec=target['Dec'] * u.deg)
fixed_target = [FixedTarget(coord=coords, name=target['name'])]
observabilities[target['name']] = []
for date in target['dates']:
# time range for transits
# Always observable for time range
if len(date) > 1:
# If exoplanet transit, test observability always during transit,
# if not, test observability *ever* during night
time_range = Time([date[0], date[1]])
# Are targets *always* observable in the time range?
observable = is_always_observable(constraints,
location,
fixed_target,
time_range=time_range)
# No time range, *ever* observabable during the night
# Observability is test from sunset to sunrise
# Default time resolution is 0.5h
else:
sunset = location.sun_set_time(Time(date[0]))
sunrise = location.sun_rise_time(Time(date[0]), 'next')
time_range = Time([sunset, sunrise])
observable = is_observable(constraints,
location,
fixed_target,
time_range=time_range)
# Moon location for the observation date
moon = location.moon_altaz(Time(date[0]))
moon_separation = moon.separation(coords)
observabilities[target['name']].append({
'observable':
str(observable[0]),
'moon_separation':
moon_separation.degree
})
return observabilities
def vis(date, objects, obj_tab):
#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')
userEntered_list = list(objects.split(","))
target_list = userEntered_list
targets = []
for i in range(1, len(obj_tab)):
ra = (obj_tab.iloc[i, 2])[1:] + ' hours'
dec = (obj_tab.iloc[i, 3])[1:] + ' degrees'
print(ra + ',' + dec)
targets.append(
FixedTarget(coord=SkyCoord(ra=ra, dec=dec),
name=target_list[i - 1]))
constraints = [
AltitudeConstraint(10 * u.deg, 80 * u.deg),
AirmassConstraint(5),
AtNightConstraint.twilight_civil()
]
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]
time_range = Time([start_time, end_time])
# In[ ]:
delta_t = end_time - start_time
observe_time = start_time + delta_t * np.linspace(0, 1, 75)
# In[ ]:
# Are targets *ever* observable in the time range?
ever_observable = is_observable(constraints,
las,
targets,
time_range=time_range)
# Are targets *always* observable in the time range?
always_observable = is_always_observable(constraints,
las,
targets,
time_range=time_range)
# During what months are the targets ever observable?
best_months = months_observable(constraints, las, targets)
# In[ ]:
table = observability_table(constraints,
las,
targets,
time_range=time_range)
print(table)
table = table.to_pandas()
np.savetxt(
'static/data/visibility.txt',
table,
fmt="%-30s",
header=
'Target name ever observable always observable fraction of time observable'
)
def observability_dates(data):
"""
Test the observability of a single objects for several nights
If the first element of 'dates' contains a single date, then
the observability is test as *ever* for the night.
If a time range is given, observability is test as *always* for the time range
Parameters
----------
data : POST data format
# data for transiting planet, time range constrained
data = {
'name' : 'Kelt 8b',
'RA' : 283.30551667 ,
'Dec' : 24.12738139,
'observatory' : 'OT',
'altitude_lower_limit' : '30',
'altitude_higher_limit' : '90',
'twilight_type' : 'astronomical',
'dates' : [
['2020-06-11 00:16:30', '2020-06-11 03:44:26'],
['2020-06-14 06:07:56', '2020-06-14 09:35:53']
]
}
# data for ordinary target, twilight constrained
# single date list
data = {
'name' : 'KIC8012732',
'RA' : 284.72949583 ,
'Dec' : 43.86421667,
'observatory' : 'OT',
'altitude_lower_limit' : '30',
'altitude_higher_limit' : '90',
'dates' : [
['2020-06-11 23:00:00']
]
}
Returns
-------
observability : dict
Dictionary with the observability and moon distance for all objects
{'V0879 Cas' : {
'observability' : 'True', 'moon_separation' : 30.4
},
'RU Scl' : {
'observability' : 'True', 'moon_separation' : 10.8
}
}
"""
import astropy.units as u
from astroplan import FixedTarget
from astroplan import (AltitudeConstraint, AtNightConstraint)
from astroplan import is_observable, is_always_observable
# Site location
location = get_location(data['observatory'])
coords = SkyCoord(ra=data['RA'] * u.deg, dec=data['Dec'] * u.deg)
fixed_target = [FixedTarget(coord=coords, name=data['name'])]
# List of dates of observability
observabilities = []
if 'twilight_type' not in data.keys():
data['twilight_type'] = 'astronomical'
if data['twilight_type'] == 'civil':
twilight_constraint = AtNightConstraint.twilight_civil()
elif data['twilight_type'] == 'nautical':
twilight_constraint = AtNightConstraint.twilight_nautical()
else:
twilight_constraint = AtNightConstraint.twilight_astronomical()
# Observation constraints
constraints = [
AltitudeConstraint(
float(data['altitude_lower_limit']) * u.deg,
float(data['altitude_higher_limit']) * u.deg), twilight_constraint
]
for date in data['dates']:
# time range for transits
# Always observable for time range
if len(data['dates'][0]) > 0:
# If exoplanet transits, check for observability always during transit,
# if not, check observability *ever* during night
time_range = Time([date[0], date[1]])
# Are targets *always* observable in the time range?
observable = is_always_observable(constraints,
location,
fixed_target,
time_range=time_range)
# No time range, *ever* observabable during the night
else:
observable = is_observable(constraints,
location,
fixed_target,
times=Time(date[0]))
# Moon location for the observation date
moon = location.moon_altaz(Time(date[0]))
moon_separation = moon.separation(coords)
observabilities.append({
'observable': str(observable[0]),
'moon_separation': moon_separation.degree
})
return observabilities
def observability(data):
"""
Test the observability of a list of objects for a single date
Parameters
----------
data : POST data format
Observatory, date, limits and objects
data = {
'observatory' : 'OT',
'date' : '2020-06-11 00:16:30',
'date_end' : '2020-06-11 03:44:26',
'altitude_lower_limit' : '30',
'altitude_higher_limit' : '90',
'twilight_type' : 'astronomical',
'objects' : [{
'name' : 'Kelt 8b',
'RA' : 283.30551667 ,
'Dec' : 24.12738139
},
(more objects...)
]
}
Returns
-------
observability : dict
Dictionary with the observability and moon distance for all objects
{
'V0879 Cas' : {
'observability' : 'True', 'moon_separation' : 30.4
},
'RU Scl' : {
'observability' : 'True', 'moon_separation' : 10.8
}
}
"""
import astropy.units as u
from astroplan import FixedTarget
from astroplan import (AltitudeConstraint, AtNightConstraint)
from astroplan import is_observable, is_always_observable
# Site location
location = get_location(data['observatory'])
time_range = Time([data['date'], data['date_end']])
if 'twilight_type' not in data.keys():
data['twilight_type'] = 'astronomical'
if data['twilight_type'] == 'civil':
twilight_constraint = AtNightConstraint.twilight_civil()
elif data['twilight_type'] == 'nautical':
twilight_constraint = AtNightConstraint.twilight_nautical()
else:
twilight_constraint = AtNightConstraint.twilight_astronomical()
# Observation constraints
constraints = [
AltitudeConstraint(
int(data['altitude_lower_limit']) * u.deg,
int(data['altitude_higher_limit']) * u.deg), twilight_constraint
]
# Dictionary with star name and observability (bool str)
result = {}
# Moon location for the observation date
middle_observing_time = time_range[-1] - (time_range[-1] -
time_range[0]) / 2
moon = location.moon_altaz(middle_observing_time)
for target in data['objects']:
# Object coordinates
coords = SkyCoord(ra=target['RA'] * u.deg, dec=target['Dec'] * u.deg)
fixed_target = [FixedTarget(coord=coords, name=target['name'])]
if 'transit' in target.keys():
time_range = Time(
[target['transit']['t_early'], target['transit']['t_late']])
# Are targets *always* observable in the time range?
observable = is_always_observable(constraints,
location,
fixed_target,
time_range=time_range)
else:
time_range = Time([data['date'], data['date_end']])
# Are targets *ever* observable in the time range?
observable = is_observable(constraints,
location,
fixed_target,
time_range=time_range)
moon_separation = moon.separation(coords)
result[target['name']] = {
'observable': str(observable[0]),
'moon_separation': moon_separation.degree
}
return result
def get_growthindia_table(json_data, sunrise_hor=-12, horizon=20,
priority=10000, domesleep=100):
"""Make .csv file in GIT toO format for a given .json file"""
t = Table(rows=json_data['targets'])
coords = SkyCoord(ra=t['ra'], dec=t['dec'], unit=(u.degree, u.degree))
hanle = EarthLocation(lat=32.77889*u.degree,
lon=78.96472*u.degree,
height=4500*u.m)
iao = Observer(location=hanle, name="GIT", timezone="Asia/Kolkata")
twilight_prime = iao.sun_rise_time(Time.now(), which="next",
horizon=sunrise_hor*u.deg) - 12*u.hour
targets_rise_time = iao.target_rise_time(twilight_prime,
coords,
which="nearest",
horizon=horizon*u.degree)
targets_set_time = iao.target_set_time(targets_rise_time, coords,
which="next",
horizon=horizon*u.degree)
rise_time_IST = np.array([(targets_rise_time + 5.5*u.hour).isot])
set_time_IST = np.array([(targets_set_time + 5.5*u.hour).isot])
tend = targets_set_time
mooncoords = get_moon(tend, hanle)
sep = mooncoords.separation(coords)
dic = {}
dic['x'] = ['']*len(t)
dic['u'] = ['']*len(t)
dic['g'] = ['']*len(t)
dic['r'] = ['']*len(t)
dic['i'] = ['']*len(t)
dic['z'] = ['']*len(t)
target = ['EMGW']*len(t)
bands = {1: 'g', 2: 'r', 3: 'i', 4: 'z', 5: 'u'}
for i in range(len(t)):
filt = bands[t[i]['filter_id']]
dic[filt][i] = '1X%i' % (t[i]['exposure_time'])
del t['request_id', 'filter_id', 'program_pi', 'program_id',
'subprogram_name', 'exposure_time']
t['field_id'].name = 'tile_id'
t['dec'].name = 'Dec'
domesleeparr = np.zeros(len(t)) + domesleep
priority = np.zeros(len(t)) + priority
minalt = AltitudeConstraint(min=horizon*u.degree)
always_up = is_always_observable(minalt, iao, coords, Time(twilight_prime,
twilight_prime+12*u.hour))
rise_time_IST[np.where(always_up)] = (twilight_prime +
5.5*u.hour).isot
set_time_IST[np.where(always_up)] = (twilight_prime +
24*u.hour +
5.5*u.hour).isot
ras_format = []
decs_format = []
ras_format = coords.ra.to_string(u.hour, sep=':')
decs_format = coords.dec.to_string(u.degree, sep=':')
# Add columns
t['domesleep'] = domesleeparr
t['Priority'] = priority
t['dec'] = decs_format
t['rise_time_IST'] = rise_time_IST
t['set_time_IST'] = set_time_IST
t['moon_angle'] = sep
t['RA'] = ras_format
t['Target'] = target
t['x'] = dic['x']
t['u'] = dic['u']
t['g'] = dic['g']
t['r'] = dic['r']
t['i'] = dic['i']
t['z'] = dic['z']
return t
# constraints = [AltitudeConstraint(10*u.deg, 80*u.deg),
# AzimuthConstraint(0*u.deg, 180*u.deg),
# AirmassConstraint(5), AtNightConstraint.twilight_civil()]
constraints = [AltitudeConstraint(10*u.deg, 80*u.deg),
AirmassConstraint(5),
AzimuthConstraint(0*u.deg, 10*u.deg),
AtNightConstraint.twilight_civil()]
from astroplan import is_observable, is_always_observable, months_observable
# Are targets *ever* observable in the time range?
ever_observable = is_observable(constraints, subaru, targets, time_range=time_range)
# Are targets *always* observable in the time range?
always_observable = is_always_observable(constraints, subaru, targets, time_range=time_range)
# During what months are the targets ever observable?
# best_months = months_observable(constraints, subaru, targets)
import numpy as np
observability_table = Table()
observability_table['targets'] = [target.name for target in targets]
observability_table['ever_observable'] = ever_observable
observability_table['always_observable'] = always_observable
print(observability_table)
def run_nights(observers, nameList, args):
# Define range of times to observe between
startDate = datetime.datetime.strptime(args.startDate,"%Y-%m-%d")
beginTimeFirstNight = datetime.datetime(startDate.year,startDate.month,startDate.day,hour=16)
endTimeFirstNight = beginTimeFirstNight + datetime.timedelta(hours=16)
t_datetimes_nights_list = []
for iDay in range(args.nNights):
beginTime = beginTimeFirstNight + datetime.timedelta(days=iDay)
endTime = endTimeFirstNight + datetime.timedelta(days=iDay)
currTime = beginTime
t_datetime = []
while currTime <= endTime:
t_datetime.append(currTime)
currTime += datetime.timedelta(hours=1)
t_datetimes_nights_list.append(t_datetime)
targets = [FixedTarget(coord=lookuptarget(name),name=name) for name in nameList]
targetLabelList, ylabelsize = makeTargetLabels(nameList,args)
constraints = [
AltitudeConstraint(min=args.minAlt*u.deg),
AtNightConstraint.twilight_astronomical(),
MoonSeparationConstraint(min=args.minMoonSep*u.deg),
MoonIlluminationConstraint(max=args.maxMoonIllum),
]
outfn = args.outFileNameBase+"_nightly.pdf"
with PdfPages(outfn) as pdf:
for observer in observers:
fig, axes = mpl.subplots(
figsize=(8.5,11),
ncols=args.nNights,
sharex="col",
gridspec_kw={
"top":0.92,
"bottom":0.03,
"left":0.13,
"right":0.98,
"hspace":0,
"wspace":0
},
tight_layout=False,constrained_layout=False
)
observability_grids = []
for iNight in range(args.nNights):
t_datetime = t_datetimes_nights_list[iNight]
time_grid = [Time(observer.timezone.localize(t)) for t in t_datetime]
observability_grid = numpy.zeros((len(targets),len(time_grid)-1))
for i in range(len(time_grid)-1):
tmp = is_always_observable(constraints, observer, targets, times=[time_grid[i],time_grid[i+1]])
observability_grid[:, i] = tmp
observability_grids.append(observability_grid)
observable_targets = targets
observable_target_labels = targetLabelList
ever_observability_grids = observability_grids
if args.onlyEverObservable:
target_is_observable = numpy.zeros(len(targets))
for observability_grid in observability_grids:
for iTime in range(observability_grid.shape[1]):
target_is_observable += observability_grid[:,iTime]
target_is_observable = target_is_observable > 0. # change to boolean numpy array
observable_targets = [x for x, o in zip(targets,target_is_observable) if o]
observable_target_labels = [x for x, o in zip(targetLabelList,target_is_observable) if o]
ever_observability_grids = []
for observability_grid in observability_grids:
ever_observability_grid = observability_grid[target_is_observable,:]
ever_observability_grids.append(ever_observability_grid)
for iNight in range(args.nNights):
ax = axes[iNight]
t_datetime = t_datetimes_nights_list[iNight]
extent = [0, len(t_datetime)-1, -0.5, len(observable_targets)-0.5]
ax.imshow(ever_observability_grids[iNight], extent=extent, origin="lower", aspect="auto", cmap=mpl.get_cmap("Greens"))
ax.xaxis.tick_top()
ax.xaxis.set_label_position("top")
ax.invert_yaxis()
if iNight == 0:
ax.set_yticks(range(0,len(observable_targets)))
ax.set_yticklabels(observable_target_labels, fontsize=ylabelsize)
else:
ax.set_yticks([])
ax.set_xticks(range(0,len(t_datetime)-1,4))
ax.set_xticks(range(0,len(t_datetime)),minor=True)
ax.set_xticklabels([t_datetime[i].strftime("%Hh") for i in range(0,len(t_datetime)-1,4)])
ax.set_xlabel(t_datetime[0].strftime("%a %b %d"))
ax.set_yticks(numpy.arange(extent[2], extent[3]), minor=True)
ax.grid(axis="x",which="minor",color="0.7",ls="-", linewidth=0.5)
ax.grid(axis="x",which="major",color="0.7",ls="-", linewidth=1)
ax.grid(axis="y",which="minor",color="0.7",ls="-", linewidth=0.5)
ax.tick_params(axis='y', which='minor', left=False, right=False)
ax.tick_params(axis='x', which='minor', bottom=False, top=False)
fig.suptitle(f"Observability at {observer.name} in {startDate.year}")
fig.text(1.0,0.0,"Constraints: Astronomical Twilight, Altitude $\geq {:.0f}^\circ$, Moon Seperation $\geq {:.0f}^\circ$, Moon Illumination $\leq {:.2f}$".format(args.minAlt,args.minMoonSep,args.maxMoonIllum),ha="right",va="bottom")
pdf.savefig(fig)
print(f"Writing out file: {outfn}")