def rise_set(source, observatory, elevation_limit=None, when=None, lst=False):
"""Rise and set times for a source"""
if isinstance(source, astroplan.FixedTarget):
S = source
elif isinstance(source, astropy.coordinates.SkyCoord):
S = astroplan.FixedTarget(source)
else:
S = astroplan.FixedTarget.from_name(source)
if isinstance(observatory, astroplan.Observer):
L = observatory
elif isinstance(observatory, astropy.coordinates.EarthLocation):
L = astroplan.Observer(observatory)
else:
try:
L = astroplan.Observer(observatory_location(observatory))
if elevation_limit is None:
elevation_limit = known_elevation_limits.get(
observatory_aliases[observatory.lower()], None)
except ValueError:
try:
L = astroplan.Observer.from_site(observatory)
except ValueError:
raise ValueError(
"Observatory {!r} not found".format(observatory))
if elevation_limit is None:
elevation_limit = 0 * u.deg
if when is None:
T = astropy.time.Time.now()
elif isinstance(when, astropy.time.Time):
T = when
else:
T = astropy.time.Time(when)
if L.target_is_up(T, S, horizon=elevation_limit):
rise = L.target_rise_time(T,
S,
which="previous",
horizon=elevation_limit)
else:
rise = L.target_rise_time(T, S, which="next", horizon=elevation_limit)
set = L.target_set_time(rise, S, which="next", horizon=elevation_limit)
rise.location = L.location
set.location = L.location
rise.format = "iso"
set.format = "iso"
if lst:
return _rise_set(
rise=format_sidereal_time(rise.sidereal_time("apparent")),
set=format_sidereal_time(set.sidereal_time("apparent")),
)
else:
return _rise_set(rise=rise, set=set)
def __init__(self, star, observatory, dataset="winter"):
super().__init__()
self.dataset = dataset
self.star = star
self.observatory = observatory
# Define target parameterss
coords = star.coordinates
self.target = astroplan.FixedTarget(name=star.name, coord=coords)
self.observer = astroplan.Observer(observatory)
# Load data
tapas_dir = join(dirname(__file__), "../../data/tapas/")
tellw, self.airw, self.angw = load_tellurics(join(tapas_dir, "*winter*ipac.gz"))
tells, self.airs, self.angs = load_tellurics(join(tapas_dir, "*summer*ipac.gz"))
# Sort wavelength axis
# We assume here that all files use the same wavelength axis
wavew, waves = np.squeeze(tellw[0, :, 0]), np.squeeze(tells[0, :, 0])
iiw, iis = np.argsort(wavew), np.argsort(waves)
self.tellw, self.tells = tellw[:, iiw, :], tells[:, iis, :]
# Create interpolator
self.wavew, self.waves = (
np.squeeze(self.tellw[0, :, 0]),
np.squeeze(self.tells[0, :, 0]),
)
self.fluxw, self.fluxs = (
np.squeeze(self.tellw[:, :, 1]),
np.squeeze(self.tells[:, :, 1]),
)
self.tellwi = RegularGridInterpolator((self.airw, self.wavew), self.fluxw)
self.tellsi = RegularGridInterpolator((self.airs, self.waves), self.fluxs)
def observer(self):
"""Return an `astroplan.Observer` representing an observer at this
facility, accounting for the latitude, longitude, and elevation."""
try:
return self._observer
except AttributeError:
if (self.lon is None or self.lon == "" or np.isnan(self.lon)
or self.lat is None or self.lat == "" or np.isnan(self.lat)
or self.fixed_location is False
or self.fixed_location is None):
self._observer = None
return self._observer
try:
elevation = self.elevation
# if elevation is not specified, assume it is 0
if (self.elevation is None or self.elevation == ""
or np.isnan(self.elevation)):
elevation = 0
self._observer = astroplan.Observer(
longitude=self.lon * u.deg,
latitude=self.lat * u.deg,
elevation=elevation * u.m,
)
except Exception as e:
log(f'Telescope {self.id} ("{self.name}") cannot calculate an observer: {e}'
)
self._observer = None
return self._observer
def airmass(self):
target = astroplan.FixedTarget(name=self.star.name,
coord=self.star.coordinates)
observer = astroplan.Observer(self.observatory_location)
altaz = observer.altaz(self.datetime, target)
airmass = altaz.secz.value
return airmass
def __init__(self, star, observatory, degree=2, skip_resample=False):
self.star = star
self.observatory = observatory
# Define target parameterss
coords = star.coordinates
self.target = astroplan.FixedTarget(name=star.name, coord=coords)
self.observer = astroplan.Observer(observatory)
self.degree = degree
self.skip_resample = skip_resample
def get_segments_tile(config_struct, observatory, radec, segmentlist):
observer = astroplan.Observer(location=observatory)
fxdbdy = astroplan.FixedTarget(coord=radec)
date_start = Time(segmentlist[0][0], format='mjd', scale='utc')
date_end = Time(segmentlist[-1][1], format='mjd', scale='utc')
tilesegmentlist = segments.segmentlist()
while date_start.mjd < date_end.mjd:
date_rise = observer.target_rise_time(date_start, fxdbdy)
date_set = observer.target_set_time(date_start, fxdbdy)
print(date_rise.mjd, date_set.mjd)
if (date_rise.mjd < 0) and (date_set.mjd < 0): break
print(date_rise.mjd, date_set.mjd)
if date_rise > date_set:
date_rise = observer.target_rise_time(
date_start - TimeDelta(24 * u.hour), fxdbdy)
print(date_rise.mjd, date_set.mjd)
segment = segments.segment(date_rise.mjd, date_set.mjd)
tilesegmentlist = tilesegmentlist + segments.segmentlist([segment])
tilesegmentlist.coalesce()
date_start = date_set + TimeDelta(24 * u.hour)
#moonsegmentlist = get_skybrightness(\
# config_struct,segmentlist,observer,fxdbdy,radec)
moonsegmentlist = get_moon_segments(\
config_struct,segmentlist,observer,fxdbdy,radec)
tilesegmentlistdic = segments.segmentlistdict()
tilesegmentlistdic["observations"] = segmentlist
tilesegmentlistdic["tile"] = tilesegmentlist
tilesegmentlistdic["moon"] = moonsegmentlist
tilesegmentlist = tilesegmentlistdic.intersection(
["observations", "tile", "moon"])
tilesegmentlist.coalesce()
return tilesegmentlist
def observer(self):
"""Return an `astroplan.Observer` representing an observer at this
facility, accounting for the latitude, longitude, elevation, and
local time zone of the observatory (if ground based)."""
try:
return self._observer
except AttributeError:
tf = timezonefinder.TimezoneFinder(in_memory=True)
local_tz = tf.closest_timezone_at(
lng=self.lon, lat=self.lat, delta_degree=5
)
self._observer = astroplan.Observer(
longitude=self.lon * u.deg,
latitude=self.lat * u.deg,
elevation=self.elevation * u.m,
timezone=local_tz,
)
return self._observer
def plot_table(tab):
min_mag = 12
lat = tab.meta['lat']
lon = tab.meta['lon']
height = tab.meta['height']
timezone = tab.meta['timezone']
location = EarthLocation(lat=lat, lon=lon, height=height)
site = astroplan.Observer(location=location,
name=tab.meta['location_name'],
timezone=timezone)
t1 = np.array([
pytz.utc.localize(datetime.fromisoformat(value))
for value in tab['time_utc']
])
tval_local = np.array([tutc.astimezone(site.timezone) for tutc in t1])
magval_local = tab['mag']
# Filter mag values above 12
mask_5 = magval_local > min_mag
tval_local_f = tval_local[mask_5]
magval_local = magval_local[mask_5]
if len(tval_local_f) > 0:
ref_time = tval_local_f[0]
elif len(tval_local) > 0:
ref_time = tval_local[0]
else:
# Empty file
return None
ref_day = datetime(year=ref_time.year,
month=ref_time.month,
day=ref_time.day,
hour=23,
minute=55,
second=0)
ref_day = site.timezone.localize(ref_day)
fig = plt.figure()
ax = fig.add_subplot()
gen_plot(ax, tval_local_f, magval_local, site, ref_day, tab.meta)
return fig
def get_segments(params, config_struct):
gpstime = params["gpstime"]
event_mjd = Time(gpstime, format='gps', scale='utc').mjd
segmentlist = segments.segmentlist()
n_windows = len(params["Tobs"]) // 2
start_segments = event_mjd + params["Tobs"][::2]
end_segments = event_mjd + params["Tobs"][1::2]
for start_segment, end_segment in zip(start_segments, end_segments):
segmentlist.append(segments.segment(start_segment, end_segment))
location = astropy.coordinates.EarthLocation(config_struct["longitude"],
config_struct["latitude"],
config_struct["elevation"])
observer = astroplan.Observer(location=location)
date_start = Time(segmentlist[0][0], format='mjd', scale='utc')
date_end = Time(segmentlist[-1][1], format='mjd', scale='utc')
nightsegmentlist = segments.segmentlist()
while date_start < date_end:
date_rise = observer.twilight_morning_astronomical(date_start)
date_set = observer.twilight_evening_astronomical(date_start)
if date_set.mjd > date_rise.mjd:
date_set = observer.twilight_evening_astronomical(
date_start - TimeDelta(24 * u.hour))
segment = segments.segment(date_set.mjd, date_rise.mjd)
nightsegmentlist = nightsegmentlist + segments.segmentlist([segment])
nightsegmentlist.coalesce()
date_start = date_rise + TimeDelta(24 * u.hour)
segmentlistdic = segments.segmentlistdict()
segmentlistdic["observations"] = segmentlist
segmentlistdic["night"] = nightsegmentlist
segmentlist = segmentlistdic.intersection(["observations", "night"])
segmentlist.coalesce()
return segmentlist
def observer_timezone(self):
"""Return an `astroplan.Observer` representing an observer at this
facility, accounting for the latitude, longitude, elevation, and
local time zone of the observatory (if ground based)."""
try:
return self._observer_timezone
except AttributeError:
if (self.lon is None or self.lon == "" or np.isnan(self.lon)
or self.lat is None or self.lat == "" or np.isnan(self.lat)
or self.fixed_location is False
or self.fixed_location is None):
self._observer_timezone = None
return self._observer_timezone
try:
tf = timezonefinder.TimezoneFinder(in_memory=True)
local_tz = tf.timezone_at(lng=(self.lon + 180) % 360 - 180,
lat=self.lat)
elevation = self.elevation
# if elevation is not specified, assume it is 0
if (self.elevation is None or self.elevation == ""
or np.isnan(self.elevation)):
elevation = 0
self._observer_timezone = astroplan.Observer(
longitude=self.lon * u.deg,
latitude=self.lat * u.deg,
elevation=elevation * u.m,
timezone=local_tz,
)
except Exception as e:
log(f'Telescope {self.id} ("{self.name}") cannot calculate an observer: {e}'
)
self._observer_timezone = None
return self._observer_timezone
def schedule(observations: List[Dict], session: Dict,
program: Dict) -> List[ObservingBlock]:
""" Return the next object to be imaged according to the 'general' scheduling
algorithm, and the time that the executor must wait before imaging this observation.
Parameters
----------
observations: List[Dict]
A list of dictionaries representing the observations to be scheduled
program: Dict
The Program object containing the configuration of this observational program
Returns
-------
obs: Dict
The next observation to be executed
wait: int
The time (in seconds) to wait before imaging this observation.
Authors: rprechelt
"""
# create observer
observatory = astroplan.Observer(
latitude=config.general.latitude * units.deg,
longitude=config.general.longitude * units.deg,
elevation=config.general.altitude * units.m,
name=config.general.name,
timezone="UTC")
# build default constraints
global_constraints = [
constraints.AltitudeConstraint(min=config.telescope.min_alt *
units.deg), # set minimum altitude
constraints.AtNightConstraint.twilight_nautical(),
constraints.TimeConstraint(min=Time(datetime.datetime.now()),
max=Time(session['end']))
]
# list to store observing blocks
blocks = []
# create targets
for observation in observations:
# check whether observation has RA and Dec values
if observation.get('RA') is None:
continue
if observation.get('Dec') is None:
continue
# target coordinates
center = SkyCoord(observation['RA'] + ' ' + observation['Dec'],
unit=(units.hourangle, units.deg))
# create and apply offset
ra_offset = Angle(observation['options'].get('ra_offset') or 0,
unit=units.arcsec)
dec_offset = Angle(observation['options'].get('dec_offset') or 0,
unit=units.arcsec)
# offset coordinates
coord = SkyCoord(center.ra + ra_offset, center.dec + dec_offset)
# create astroplan traget
target = FixedTarget(coord=coord, name=observation['target'])
# priority - if the observation has a priority, otherwise 1
priority = observation['options'].get('priority') or 1
# if specified, restrict airmass, otherwise no airmass restriction
max_airmass = observation['options'].get('airmass') or 38
airmass = constraints.AirmassConstraint(
max=max_airmass, boolean_constraint=False) # rank by airmass
# if specified, use observations moon separation, otherwise use 2 degrees
moon_sep = (observation['options'].get('moon')
or config.queue.moon_separation) * units.deg
moon = constraints.MoonSeparationConstraint(min=moon_sep)
# time, airmass, moon, + altitude, and at night
local_constraints = [moon]
# create observing block for this target
blocks.append(
ObservingBlock.from_exposures(
target,
priority,
observation['exposure_time'] * units.second,
observation['exposure_count'] *
(len(observation['filters']) + 1),
config.telescope.readout_time * units.second,
configuration=observation,
constraints=local_constraints))
# we need to create a transitioner to go between blocks
transitioner = astroplan.Transitioner(
1 * units.deg / units.second,
{'filter': {
'default': 4 * units.second
}})
# create priority scheduler
priority_scheduler = scheduling.PriorityScheduler(
constraints=global_constraints,
observer=observatory,
transitioner=transitioner)
# initialize the schedule
schedule = scheduling.Schedule(Time.now(), Time(session['end']))
# schedule!
schedule = priority_scheduler(blocks, schedule)
# print(schedule.to_table())
# print(f'observing_blocks: {schedule.observing_blocks}')
# print(f'open_slots: {schedule.open_slots}')
# print(f'scheduled_blocks: {schedule.scheduled_blocks}')
# return the scheduled blocks
return schedule
def __init__(self,
startdate="",
stopdate="",
twilight_angle=-18.,
verbose=True):
"""
EXAMPLE:
startdate = '2018-02-25 05:00:00'
stopdate = '2018-03-05 05:00:00'
"""
print("Using Twilight = {}".format(twilight_angle))
self.hetloc = astropy.coordinates.EarthLocation.of_site(
'McDonald Observatory')
self.observer = astroplan.Observer(location=self.hetloc)
#################################
all_times = het_helper_functions.arange_time(
startdate, stopdate, form=None) # array of astropy.time.Time()
self.num_nights = len(all_times)
jd_arr = [i.jd for i in all_times]
hori = astropy.coordinates.Angle(twilight_angle,
unit=u.degree) # have used -12
print("Creating array of {} nights to check observability".format(
self.num_nights))
#################################
print("Calculating Sunrise/Sunset Times")
sunrise_times, sunset_times, self.times_night_all_lst = [], [], []
for i in tqdm(all_times):
sunrise_times.append(
astropy.time.Time(self.observer.sun_rise_time(i,
which='nearest',
horizon=hori),
location=self.hetloc))
sunset_times.append(
astropy.time.Time(self.observer.sun_set_time(i,
which='nearest',
horizon=hori),
location=self.hetloc))
self.df_time = pd.DataFrame({
'jd': jd_arr,
'time': all_times,
'sunset_time': sunset_times,
'sunrise_time': sunrise_times
})
#################################
print("Calculating Local Sidereal Times")
for i in tqdm(self.df_time.index):
jd_1 = self.df_time.loc[i, 'sunset_time'].jd
jd_2 = self.df_time.loc[i, 'sunrise_time'].jd
jds_night = linspace(jd_1, jd_2, 100)
self.times_night_all_lst.append([
astropy.time.Time(
i, format='jd',
location=self.hetloc).sidereal_time('mean').degree
for i in jds_night
])
#################################
# Setting observability limits
decs = linspace(
-90., 90.,
10000) #dindgen(1d5)/1d5*180d - 90d ;declinations to try
decs_rad = radians(decs) #del_rad = del * !dtor
phi = self.hetloc.lat.radian
alt1 = radians(het_config.HET_MAX_ALT)
alt2 = radians(het_config.HET_MIN_ALT)
h1 = degrees(
arccos((sin(alt1) - sin(decs_rad) * sin(phi)) /
(cos(decs_rad) * cos(phi))))
h2 = degrees(
arccos((sin(alt2) - sin(decs_rad) * sin(phi)) /
(cos(decs_rad) * cos(phi))))
# The following structure shows the observability limits for each declination value
# where limits are degrees from zenith (hour angle), and are symmetric across zenith
# (ie negative limits also apply)
self.obs_limits = {
'h1': h1,
'h2': h2,
'decs': decs,
'alt1': alt1,
'alt2': alt2
}
print("Finished loading observability limits for all nights")
import inspect
import numpy as np
from astropy.time import Time
import astropy.coordinates as coords
import astropy.units as u
import astroplan
BASE_DIR = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe()))) + '/'
P48_loc = coords.EarthLocation(lat=coords.Latitude('33d21m26.35s'),
lon=coords.Longitude('-116d51m32.04s'),
height=1707.)
# use UTC only
P48_Observer = astroplan.Observer(location=P48_loc)
# HA and Dec from http://www.oir.caltech.edu/twiki_oir/bin/view/Palomar/ZTF/TelescopeSpecifications v5
# Dome estimate from Jeff Z email, 9/21/15
# goals info from Jeff Z email, 12/12/16
# Ha/Dec from Telescope Drive Performance Assessment v1.2; dome estimate from
# Jeff Z. email, 9/27/17
P48_slew_pars = {
'ha': {
'coord': 'ra',
'accel': 0.4 * u.deg * u.second**(-2.),
'decel': 0.4 * u.deg * u.second**(-2.),
'vmax': 2.5 * u.deg / u.second
},
'dec': {
'coord': 'dec',
import astroplan
from astropy.coordinates import solar_system_ephemeris
solar_system_ephemeris.set('jpl')
import numpy as np
from scipy.stats import norm
import matplotlib.pyplot as plt
import datetime
# Posicion del observador (IAR)
lat = -34.8601
lon = -58.1385
h = 20
IAR = EarthLocation(lat=lat, lon=lon, height=h*u.m)
observer = astroplan.Observer(location = IAR, timezone='America/Buenos_Aires')
localtz = TimezoneInfo(utc_offset=-3 * u.hour)
# Limites de la antena
EASTLIMIT = -29
WESTLIMIT = +29
NORTHLIMIT = -10
SOUTHLIMIT = -90
# Algunos TimeDeltas
# 1 Minuto
oneMin = TimeDelta(val = 60, format='sec')
# 5 Minutos
fiveMins = TimeDelta(val = 300, format='sec')
# 10 Minutos
def params_checker(params):
#assigns defaults to params
do_Parameters = [
"do3D", "doEvent", "doSuperSched", "doMovie_supersched", "doSkymap",
"doSamples", "doCoverage", "doSchedule", "doPlots", "doDatabase",
"doMovie", "doTiles", "doIterativeTiling", "doMinimalTiling",
"doOverlappingScheduling", "doPerturbativeTiling",
"doOrderByObservability", "doCatalog", "doUseCatalog",
"doCatalogDatabase", "doObservability", "doSkybrightness",
"doEfficiency", "doCalcTiles", "doTransients", "doSingleExposure",
"doAlternatingFilters", "doMaxTiles", "doReferences", "doChipGaps",
"doUsePrimary", "doSplit", "doParallel", "writeCatalog", "doFootprint",
"doBalanceExposure"
]
for parameter in do_Parameters:
if parameter not in params.keys():
params[parameter] = False
if "skymap" not in params.keys():
params["skymap"] = '../output/skymaps/G268556.fits'
if "gpstime" not in params.keys():
params["gpstime"] = 1167559936.0
if "outputDir" not in params.keys():
params["outputDir"] = "../output"
if "tilingDir" not in params.keys():
params["tilingDir"] = "../tiling"
if "catalogDir" not in params.keys():
params["catalogDir"] = "../catalogs"
if "event" not in params.keys():
params["event"] = "G268556"
if "coverageFiles" not in params.keys():
params["coverageFiles"] = "../data/ATLAS_GW170104.dat"
if "telescopes" not in params.keys():
params["telescopes"] = 'ATLAS'
if type(params["telescopes"]) == str:
params["telescopes"] = params["telescopes"].split(",")
if "lightcurveFiles" not in params.keys():
params["lightcurveFiles"] = "../lightcurves/Me2017_H4M050V20.dat"
if "tilesType" not in params.keys():
params["tilesType"] = "moc"
if "scheduleType" not in params.keys():
params["scheduleType"] = "greedy"
if "timeallocationType" not in params.keys():
params["timeallocationType"] = "powerlaw"
if "Ninj" not in params.keys():
params["Ninj"] = 1000
if "Ndet" not in params.keys():
params["Ndet"] = 1
if "Ntiles" not in params.keys():
params["Ntiles"] = 10
if "Ntiles_cr" not in params.keys():
params["Ntiles_cr"] = 0.70
if "Dscale" not in params.keys():
params["Dscale"] = 1.0
if "nside" not in params.keys():
params["nside"] = 256
if "Tobs" not in params.keys():
params["Tobs"] = np.array([0.0, 1.0])
if "powerlaw_c1" not in params.keys():
params["powerlaw_c1"] = 0.9
if "powerlaw_n" not in params.keys():
params["powerlaw_n"] = 1.0
if "powerlaw_dist_exp" not in params.keys():
params["powerlaw_dist_exp"] = 0
if "galaxies_FoV_sep" not in params.keys():
params["galaxies_FoV_sep"] = 1.0
if "footprint_ra" not in params.keys():
params["footprint_ra"] = 30.0
if "footprint_dec" not in params.keys():
params["footprint_dec"] = 60.0
if "footprint_radius" not in params.keys():
params["footprint_radius"] = 10.0
if "transientsFile" not in params.keys():
params["transientsFile"] = "../transients/ps1_objects.csv"
if "dt" not in params.keys():
params["dt"] = 14.0
if "galaxy_catalog" not in params.keys():
params["galaxy_catalog"] = "GLADE"
if "filters" not in params.keys():
params["filters"] = ['r', 'g', 'r']
if "exposuretimes" not in params.keys():
params["exposuretimes"] = np.array([30.0, 30.0, 30.0])
if "max_nb_tiles" not in params.keys():
params["max_nb_tiles"] = np.array([-1, -1, -1])
if "mindiff" not in params.keys():
params["mindiff"] = 0.0
if "airmass" not in params.keys():
params["airmass"] = 2.5
if "iterativeOverlap" not in params.keys():
params["iterativeOverlap"] = 0.0
if "maximumOverlap" not in params.keys():
params["maximumOverlap"] = 1.0
if "catalog_n" not in params.keys():
params["catalog_n"] = 1.0
if "galaxy_grade" not in params.keys():
params["galaxy_grade"] = "S"
if "splitType" not in params.keys():
params["splitType"] = "regional"
if "Nregions" not in params.keys():
params["Nregions"] = 768
if "configDirectory" not in params.keys():
params["configDirectory"] = "../config/"
if "Ncores" not in params.keys():
params["Ncores"] = 4
if "config" not in params.keys():
params["config"] = {}
configFiles = glob.glob("%s/*.config" % params["configDirectory"])
for configFile in configFiles:
telescope = configFile.split("/")[-1].replace(".config", "")
if not telescope in params["telescopes"]: continue
params["config"][telescope] = gwemopt.utils.readParamsFromFile(
configFile)
params["config"][telescope]["telescope"] = telescope
if params["doSingleExposure"]:
exposuretime = np.array(opts.exposuretimes.split(","),
dtype=np.float)[0]
nmag = np.log(
exposuretime /
params["config"][telescope]["exposuretime"]) / np.log(2.5)
params["config"][telescope]["magnitude"] = params["config"][
telescope]["magnitude"] + nmag
params["config"][telescope]["exposuretime"] = exposuretime
if "tesselationFile" in params["config"][telescope]:
if not os.path.isfile(
params["config"][telescope]["tesselationFile"]):
if params["config"][telescope]["FOV_type"] == "circle":
gwemopt.tiles.tesselation_spiral(
params["config"][telescope])
elif params["config"][telescope]["FOV_type"] == "square":
gwemopt.tiles.tesselation_packing(
params["config"][telescope])
if params["tilesType"] == "galaxy":
params["config"][telescope]["tesselation"] = np.empty(
(3, ))
else:
params["config"][telescope]["tesselation"] = np.loadtxt(
params["config"][telescope]["tesselationFile"],
usecols=(0, 1, 2),
comments='%')
if "referenceFile" in params["config"][telescope]:
refs = table.unique(
table.Table.read(
params["config"][telescope]["referenceFile"],
format='ascii',
data_start=2,
data_end=-1)['field', 'fid'])
reference_images =\
{group[0]['field']: group['fid'].astype(int).tolist()
for group in refs.group_by('field').groups}
reference_images_map = {1: 'g', 2: 'r', 3: 'i'}
for key in reference_images:
reference_images[key] = [
reference_images_map.get(n, n)
for n in reference_images[key]
]
params["config"][telescope][
"reference_images"] = reference_images
location = astropy.coordinates.EarthLocation(
params["config"][telescope]["longitude"],
params["config"][telescope]["latitude"],
params["config"][telescope]["elevation"])
observer = astroplan.Observer(location=location)
params["config"][telescope]["observer"] = observer
return params
elevation = 220
# daysOfTheYear = [datetime(2020, x,) for x in range(1,13)]
# startDate = datetime(1678, 1,1)
startDate = datetime(2020, 1,1,12)
# endDate = datetime(2020, 1,20)
# startDate = datetime(2020, 12,10)
endDate = datetime(2020, 12,31)
# endDate = datetime(2020, 12,31)
__cores = cpu_count()
daysOfTheYear = astropy.time.Time(pd.date_range(startDate,endDate,freq='d'))
daysOfTheYear = daysOfTheYear[::6]
observerLocation = astropy.coordinates.EarthLocation(lat=latitude*u.deg, lon=longitude*u.deg, height=elevation*u.m)
# observer = astroplan.Observer(observerLocation,name="Krakow", timezone="Europe/Warsaw")
observer = astroplan.Observer(observerLocation)
sun = astropy.coordinates.get_sun(daysOfTheYear[0])
moon = astropy.coordinates.get_moon(daysOfTheYear[0])
toPlot_sun = [{"day": day, "observer": observer, "observerLocation": observerLocation,
"target": sun} for day in daysOfTheYear]
toPlot_moon = [{"day": day, "observer": observer, "observerLocation": observerLocation,
"target": moon} for day in daysOfTheYear]
with Pool(processes=__cores) as pool:
toPlot_sun = pool.map(getCelestialArgs, toPlot_sun)
toPlot_moon = pool.map(getCelestialArgs, toPlot_moon)
toPlot_sun = pd.DataFrame(toPlot_sun)
toPlot_moon = pd.DataFrame(toPlot_moon)
plotTarget("Sun",toPlot_sun)
duration=transit_duration2)
midnight = Time('2020-7-13 00:00:00') - utcoffset
delta_midnight = np.linspace(-12, 12, 1000) * u.hour
times_July12_to_13 = midnight + delta_midnight
frame_July12_to_13 = AltAz(obstime=times_July12_to_13, location=paranal_loc)
sunaltazs_July12_to_13 = get_sun(times_July12_to_13).transform_to(
frame_July12_to_13)
GJ9827baltaz = GJ9827b.transform_to(AltAz(obstime=time, location=paranal_loc))
delta_midnight = np.linspace(-2, 10, 100) * u.hour
obstime = midnight + delta_midnight
paranal = astroplan.Observer(paranal_loc, timezone='Etc/GMT-4')
Altcons = astroplan.AltitudeConstraint(min=+30 * u.deg, max=None)
Airmasscons = astroplan.AirmassConstraint(min=None, max=3.0)
Alt_constraints = Altcons.compute_constraint(times=obstime,
observer=paranal,
targets=GJ9827b)
Airmass_constraints = Airmasscons.compute_constraint(times=obstime,
observer=paranal,
targets=GJ9827b)
observable = astroplan.is_observable(constraints=[Altcons, Airmasscons],
observer=paranal,
targets=GJ9827b,
times=obstime)
# plot the motion in the sky for a given hour of the night with passing of days
# for a given date and a list of objects: produce
# filter the list based on observability for that date
# plot their motion in the sky
import astroplan, astroplan.plots
import astropy.coordinates, astropy.time
import astropy.units as u
import numpy, pandas, pytz, datetime, click
import matplotlib.pyplot as plt
import astroquery.vizier
astropy.coordinates.solar_system_ephemeris.set('jpl')
polse = astroplan.Observer(latitude=46 + (28 + 9.1 / 60) / 60,
longitude=13 + (0 + 42.6 / 60) / 60,
elevation=750 * u.meter,
timezone=pytz.timezone('Europe/Rome'))
polse_constraints = [
astroplan.AltitudeConstraint(min=20 * u.deg),
astroplan.AtNightConstraint.twilight_civil(),
astroplan.MoonSeparationConstraint(min=20 * u.deg),
astroplan.LocalTimeConstraint(min=datetime.time(20, 0),
max=datetime.time(1, 0))
]
months_labels = [
'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct',
'Nov', 'Dec'
]
def schedule(observations: List[Dict], session: Dict, program: Dict) -> List[ObservingBlock]:
""" Return the next object to be imaged according to the 'general' scheduling
algorithm, and the time that the executor must wait before imaging this observation.
Parameters
----------
observations: List[Dict]
A list of dictionaries representing the observations to be scheduled
program: Dict
The Program object containing the configuration of this observational program
Returns
-------
obs: Dict
The next observation to be executed
wait: int
The time (in seconds) to wait before imaging this observation.
Authors: rprechelt
"""
# create observer
observatory = astroplan.Observer(latitude=config.general.latitude*units.deg,
longitude=config.general.longitude*units.deg,
elevation=config.general.altitude*units.m,
name="Atlas", timezone="UTC")
# build default constraints
global_constraints = [constraints.AltitudeConstraint(min=40*units.deg), # set minimum altitude
constraints.AtNightConstraint.twilight_nautical()] # sun below -18
# list to store observing blocks
blocks = []
# create targets
for observation in observations:
# target coordinates
center = SkyCoord(observation['RA']+' '+observation['Dec'], unit=(units.hourangle, units.deg))
# create and apply offset
ra_offset = Angle(observation['options'].get('ra_offset') or 0, unit=units.arcsec)
dec_offset = Angle(observation['options'].get('dec_offset') or 0, unit=units.arcsec)
# offset coordinates
coord = SkyCoord(center.ra + ra_offset, center.dec + dec_offset)
# create astroplan traget
target = FixedTarget(coord=coord, name=observation['target'])
# priority - if the observation has a priority, otherwise 1
priority = observation['options'].get('priority') or 1
# create local constraints
ltc = constraints.LocalTimeConstraint(min=datetime.datetime.now().time(),
max=session['end'].time())
# if specified, restrict airmass, otherwise no airmass restriction
max_airmass = observation['options'].get('airmass') or 38
airmass = constraints.AirmassConstraint(max=max_airmass, boolean_constraint = False)] # rank by airmass
# if specified, use observations moon separation, otherwise use 2 degrees
moon_sep = observation['options'].get('moon')*units.deg or 2*units.deg
moon = constraints.MoonSeparationConstraint(min=moon_sep*units.deg),
# time, airmass, moon, + altitude, and at night
constraints = [ltc, airmass, moon]
# create observing block for this target
blocks.append(ObservingBlock.from_exposures(target, priority, observation['exposure_time']*units.second,
observation['exposure_count']*len(observation['filters']),
config.telescope.readout_time*units.second,
configuration = observation,
constraints = [ltc]))
# we need to create a transitioner to go between blocks
transitioner = astroplan.Transitioner(1*units.deg/units.second,
{'filter': {'default': 3*units.second}})
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()
