def suggest_targets(self, time):
Proposal.suggest_targets(self, time)
if self.targetid < len(self.targetsList):
nexttarget = self.targetsList[self.targetid]
else:
nexttarget = self.targetsList[-1]
nexttarget.targetid = self.targetid
nexttarget.time = time
nexttarget.value = 1.0
target_list = list([nexttarget])
id_list = []
ra_list = []
dec_list = []
filter_list = []
for target in target_list:
id_list.append(target.fieldid)
ra_list.append(target.ra_rad)
dec_list.append(target.dec_rad)
filter_list.append(target.filter)
self.sky.update(time)
sky_mags = self.sky.get_sky_brightness(numpy.array(ra_list),
numpy.array(dec_list))
target_list[0].sky_brightness = sky_mags[target.filter][0]
self.targetid += 1
return target_list
def __init__(self, propid, name, confdict, scriptfile, skymodel):
Proposal.__init__(self, propid, name, confdict, skymodel)
self.script_file = scriptfile
self.read_script()
self.targetid = 0
def end_night(self, timestamp):
Proposal.end_night(self, timestamp)
self.fieldsvisitedtonight.clear()
self.log.info(
"end_night survey fields=%i targets=%i goal=%i visits=%i progress=%.2f%%"
%
(self.survey_fields, self.survey_targets, self.survey_targets_goal,
self.survey_targets_visits, 100 * self.survey_targets_progress))
def start_night(self, timestamp, filters_mounted_tonight_list, night):
Proposal.start_night(self, timestamp, filters_mounted_tonight_list,
night)
self.tonight_filters_list = []
self.tonight_targets = 0
self.tonight_sequences_dict = {}
for filter in filters_mounted_tonight_list:
self.tonight_filters_list.append(filter)
self.build_tonight_fields_list(timestamp, night)
self.tonight_fields = len(self.tonight_fields_list)
# compute at start night
for field in self.tonight_fields_list:
fieldid = field.fieldid
# add new fields to fields dictionary
if fieldid not in self.survey_fields_dict:
self.survey_fields_dict[fieldid] = field.get_copy()
self.survey_fields += 1
# add new fields to sequences dictionary
if fieldid not in self.survey_sequences_dict:
sequence = self.create_sequence(field)
self.survey_sequences_dict[fieldid] = sequence
self.survey_sequences += 1
self.survey_targets_goal += sequence.goal
for filter in sequence.filters_goal_dict:
self.survey_filters_goal_dict[
filter] += sequence.filters_goal_dict[filter]
else:
sequence = self.survey_sequences_dict[fieldid]
if sequence.is_idle_or_active():
self.tonight_sequences_dict[fieldid] = sequence
self.tonight_sequences += 1
for filter in self.params.filter_list:
if self.survey_filters_goal_dict[filter] > 0:
self.survey_filters_progress_dict[filter] = \
float(self.survey_filters_visits_dict[filter]) / self.survey_filters_goal_dict[filter]
else:
self.survey_filters_progress_dict[filter] = 0.0
self.log.debug("start_night tonight fields=%i sequences=%i" %
(self.tonight_fields, self.tonight_sequences))
self.last_observation = None
self.last_observation_was_for_this_proposal = False
self.in_deep_drilling = False
def end_night(self, timestamp):
Proposal.end_night(self, timestamp)
if self.in_deep_drilling:
fieldid = self.last_observation.fieldid
sequence = self.tonight_sequences_dict[fieldid]
ssname = self.last_observation.subsequencename
sequence.miss_observation_subsequence(ssname, timestamp)
self.log.debug("end_night: miss observation field=%i, ssname=%s" %
(fieldid, ssname))
self.evaluate_sequence_continuation(fieldid, "end of night")
self.in_deep_drilling = False
self.log.info(
"end_night survey fields=%i sequences=%i goal=%i visits=%i progress=%.2f%%"
% (self.survey_fields, self.survey_sequences,
self.survey_targets_goal, self.survey_targets_visits,
100 * self.get_progress()))
def __init__(self, propid, name, confdict, skymodel):
Proposal.__init__(self, propid, name, confdict, skymodel)
self.log.debug('TimeDistributionProposal - %s: %s' % (name, confdict))
self.params = TimeDistributionProposalParameters(
self.proposal_confdict)
self.sky.configure(self.params.exclude_planets)
# cummulative data for the survey
self.survey_fields = 0
self.survey_fields_dict = {}
self.survey_sequences = 0
self.survey_sequences_dict = {}
self.survey_targets_goal = 0
self.survey_targets_visits = 0
self.survey_filters_goal_dict = {}
self.survey_filters_visits_dict = {}
self.survey_filters_progress_dict = {}
for filter in self.params.filter_list:
self.survey_filters_goal_dict[filter] = 0
self.survey_filters_visits_dict[filter] = 0
self.survey_filters_progress_dict[filter] = 0.0
# cummulative data for one night
self.tonight_filters_list = []
self.tonight_fields = 0
self.tonight_fields_list = []
self.tonight_fieldid_list = []
self.tonight_sequences = 0
self.tonight_sequences_dict = {}
# data for one visit
self.valued_targets_list = []
self.last_observation = None
self.last_observation_was_for_this_proposal = False
self.in_deep_drilling = False
def suggest_targets(self,
timestamp,
deepdrilling_target,
constrained_filter,
cloud,
seeing,
lookahead=None):
Proposal.suggest_targets(self, timestamp)
if self.ignore_clouds:
cloud = 0.0
if self.ignore_seeing:
seeing = 0.0
if cloud > self.params.max_cloud:
self.log.debug("suggest_targets: cloud=%.2f > max_cloud=%.2f" %
(cloud, self.params.max_cloud))
return []
self.clear_evaluated_target_list()
# evaluates previous deep drilling state with new target
if self.in_deep_drilling:
if deepdrilling_target is None:
# deep drilling event interrupted
fieldid = self.last_observation.fieldid
sequence = self.tonight_sequences_dict[fieldid]
ssname = self.last_observation.subsequencename
sequence.miss_observation_subsequence(ssname, timestamp)
self.log.debug(
"suggest_observation: miss observation field=%i, ssname=%s"
% (fieldid, ssname))
self.evaluate_sequence_continuation(fieldid, "interrupted")
fields_evaluation_list = self.tonight_fields_list
num_targets_to_propose = self.params.max_num_targets
self.in_deep_drilling = False
else:
if self.observation_fulfills_target(deepdrilling_target,
self.last_observation):
# deep drilling event continues
fields_evaluation_list = [
self.survey_fields_dict[deepdrilling_target.fieldid]
]
num_targets_to_propose = 1
else:
# deep drilling event is not for this proposal
# deep drilling event interrupted
fieldid = self.last_observation.fieldid
sequence = self.tonight_sequences_dict[fieldid]
ssname = self.last_observation.subsequencename
sequence.miss_observation_subsequence(ssname, timestamp)
self.log.debug(
"suggest_observation: miss observation field=%i, ssname=%s"
% (fieldid, ssname))
self.evaluate_sequence_continuation(fieldid, "interrupted")
fields_evaluation_list = self.tonight_fields_list
num_targets_to_propose = self.params.max_num_targets
self.in_deep_drilling = False
else:
if deepdrilling_target is None:
fields_evaluation_list = self.tonight_fields_list
num_targets_to_propose = self.params.max_num_targets
else:
if deepdrilling_target.fieldid in self.tonight_fieldid_list:
fields_evaluation_list = [
self.survey_fields_dict[deepdrilling_target.fieldid]
]
if self.propid in deepdrilling_target.propid_list:
# deep drilling event starts
num_targets_to_propose = 1
self.in_deep_drilling = True
else:
# deep drilling event is not for this proposal
num_targets_to_propose = 0
else:
fields_evaluation_list = []
num_targets_to_propose = 0
if constrained_filter is None:
filters_evaluation_list = self.tonight_filters_list
else:
filters_evaluation_list = [constrained_filter]
# compute sky brightness for all targets
id_list = []
ra_rad_list = []
dec_rad_list = []
mags_dict = {}
airmass_dict = {}
hour_angle_dict = {}
moon_distance_dict = {}
for field in fields_evaluation_list:
# create coordinates arrays
id_list.append(field.fieldid)
ra_rad_list.append(field.ra_rad)
dec_rad_list.append(field.dec_rad)
if (len(id_list) > 0) and (not self.ignore_sky_brightness
or not self.ignore_airmass):
self.sky.update(timestamp)
sky_mags = self.sky.get_sky_brightness(numpy.array(ra_rad_list),
numpy.array(dec_rad_list))
airmass = self.sky.get_airmass(numpy.array(ra_rad_list),
numpy.array(dec_rad_list))
nra = numpy.array(ra_rad_list)
moon_distance = self.sky.get_separation("moon", nra,
numpy.array(dec_rad_list))
hour_angle = self.sky.get_hour_angle(nra)
for ix, fieldid in enumerate(id_list):
mags_dict[fieldid] = {k: v[ix] for k, v in sky_mags.items()}
airmass_dict[fieldid] = airmass[ix]
moon_distance_dict[fieldid] = moon_distance[ix]
hour_angle_dict[fieldid] = hour_angle[ix]
if self.in_deep_drilling:
fieldid = deepdrilling_target.fieldid
sequence = self.tonight_sequences_dict[fieldid]
target = sequence.get_next_target_subsequence(
deepdrilling_target.subsequencename)
filter = target.filter
if self.ignore_airmass:
airmass = 1.0
else:
airmass = airmass_dict[fieldid]
if self.ignore_sky_brightness:
sky_brightness = 0.0
else:
sky_brightness = mags_dict[fieldid][filter]
if math.isnan(sky_brightness):
sky_brightness = 0.0
target.time = timestamp
target.airmass = airmass
target.sky_brightness = sky_brightness
target.cloud = cloud
target.seeing = seeing
target.need = 1.0
target.bonus = 0.0
target.value = target.need + target.bonus
self.add_evaluated_target(target)
self.log.log(EXTENSIVE, "suggest_targets: in deep drilling")
return self.get_evaluated_target_list(1)
# not in deep drilling (yet)
evaluated_fields = 0
discarded_fields_airmass = 0
discarded_fields_notargets = 0
discarded_targets_notallfilters = 0
discarded_targets_consecutive = 0
discarded_targets_nanbrightness = 0
discarded_targets_lowbrightness = 0
discarded_targets_highbrightness = 0
discarded_targets_seeing = 0
discarded_moon_distance = 0
evaluated_targets = 0
missed_subsequences_list = []
# compute target value
for field in fields_evaluation_list:
fieldid = field.fieldid
# discard fields with no more targets tonight
if fieldid not in self.tonight_sequences_dict:
discarded_fields_notargets += 1
continue
sequence = self.tonight_sequences_dict[fieldid]
# discard fields beyond airmass limit
if self.ignore_airmass:
airmass = 1.0
else:
airmass = airmass_dict[fieldid]
if airmass > self.params.max_airmass:
discarded_fields_airmass += 1
continue
moon_distance = moon_distance_dict[fieldid]
if moon_distance < self.params.min_distance_moon_rad:
discarded_moon_distance += 1
continue
airmass_rank = self.params.airmass_bonus * \
(self.params.max_airmass - airmass) / (self.params.max_airmass - 1.0)
hour_angle_rank = self.params.hour_angle_bonus * \
(1.0 - numpy.abs(hour_angle_dict[fieldid]) / self.params.hour_angle_max_rad)
for name in sequence.enabled_subsequences_list:
target = sequence.get_next_target_subsequence(name)
filter = target.filter
filter_list = sequence.get_next_filter_list_subsequence(name)
# discard target with unavailable filters
any_filter_unavailable = False
for f in filter_list:
if f not in filters_evaluation_list:
any_filter_unavailable = True
break
if any_filter_unavailable:
discarded_targets_notallfilters += 1
continue
# discard target beyond seeing limit
any_filter_bad_seeing = False
for f in filter_list:
if seeing > self.params.filter_max_seeing_dict[f]:
any_filter_bad_seeing = True
break
if any_filter_bad_seeing:
discarded_targets_seeing += 1
continue
target.time = timestamp
target.airmass = airmass
# discard target if consecutive
if self.last_observation_was_for_this_proposal:
if (self.observation_fulfills_target(
self.last_observation, target)
and not self.params.accept_consecutive_visits):
discarded_targets_consecutive += 1
continue
if self.ignore_sky_brightness:
sky_brightness = 0.0
else:
# discard target beyond sky brightness limits
any_filter_bad_brightness = False
for f in filter_list:
sky_brightness = mags_dict[fieldid][f]
if math.isnan(sky_brightness):
any_filter_bad_brightness = True
discarded_targets_nanbrightness += 1
break
if sky_brightness < self.params.filter_min_brig_dict[f]:
any_filter_bad_brightness = True
discarded_targets_lowbrightness += 1
break
if sky_brightness > self.params.filter_max_brig_dict[f]:
any_filter_bad_brightness = True
discarded_targets_highbrightness += 1
break
if any_filter_bad_brightness:
continue
# target is accepted
# compute value for available targets
target.sky_brightness = sky_brightness
target.cloud = cloud
target.seeing = seeing
time_rank = sequence.time_window_subsequence(name, timestamp)
need_ratio = time_rank
if need_ratio > 0.0:
# target is needed
target.need = need_ratio
target.bonus = airmass_rank + hour_angle_rank
target.value = target.need + target.bonus
self.add_evaluated_target(target)
elif need_ratio < 0.0:
# subsequence event missed
missed_subsequences_list.append((fieldid, name))
evaluated_targets += 1
evaluated_fields += 1
for (fieldid, name) in missed_subsequences_list:
self.survey_sequences_dict[fieldid].miss_observation_subsequence(
name, timestamp)
self.log.debug(
"suggest_targets: miss observation field=%i, ssname=%s" %
(fieldid, name))
self.evaluate_sequence_continuation(fieldid, "missed observation")
self.log.log(
EXTENSIVE, "suggest_targets: fields=%i, evaluated=%i, "
"discarded airmass=%i notargets=%i" %
(len(id_list), evaluated_fields, discarded_fields_airmass,
discarded_fields_notargets))
self.log.log(
EXTENSIVE,
"suggest_targets: evaluated targets=%i, discarded consecutive=%i "
"notallfilters=%i seeing=%i "
"lowbright=%i highbright=%i nanbright=%i moondistance=%i" %
(evaluated_targets, discarded_targets_consecutive,
discarded_targets_notallfilters, discarded_targets_seeing,
discarded_targets_lowbrightness, discarded_targets_highbrightness,
discarded_targets_nanbrightness, discarded_moon_distance))
return self.get_evaluated_target_list(num_targets_to_propose)
def start_survey(self):
Proposal.start_survey(self)
def suggest_targets(self,
timestamp,
deepdrilling_target,
constrained_filter,
cloud,
seeing,
lookahead=None):
Proposal.suggest_targets(self, timestamp)
if self.ignore_clouds:
cloud = 0.0
if self.ignore_seeing:
seeing = 0.0
if cloud > self.params.max_cloud:
self.log.debug("suggest_targets: cloud=%.2f > max_cloud=%.2f" %
(cloud, self.params.max_cloud))
return []
self.clear_evaluated_target_list()
if deepdrilling_target is None:
fields_evaluation_list = self.tonight_fields_list
num_targets_to_propose = self.params.max_num_targets
else:
if deepdrilling_target.fieldid in self.tonight_fields_list:
fields_evaluation_list = [
self.survey_fields_dict[deepdrilling_target.fieldid]
]
else:
fields_evaluation_list = []
num_targets_to_propose = 0
if constrained_filter is None:
filters_evaluation_list = self.tonight_filters_list
else:
filters_evaluation_list = [constrained_filter]
# compute sky brightness for all targets
id_list = []
ra_rad_list = []
dec_rad_list = []
mags_dict = {}
airmass_dict = {}
hour_angle_dict = {}
moon_distance_dict = {}
for field in fields_evaluation_list:
# create coordinates arrays
id_list.append(field.fieldid)
ra_rad_list.append(field.ra_rad)
dec_rad_list.append(field.dec_rad)
if (len(id_list) > 0) and (not self.ignore_sky_brightness
or not self.ignore_airmass):
self.sky.update(timestamp)
sky_mags = self.sky.get_sky_brightness(numpy.array(ra_rad_list),
numpy.array(dec_rad_list))
airmass = self.sky.get_airmass(numpy.array(ra_rad_list),
numpy.array(dec_rad_list))
nra = numpy.array(ra_rad_list)
moon_distance = self.sky.get_separation("moon", nra,
numpy.array(dec_rad_list))
hour_angle = self.sky.get_hour_angle(nra)
for ix, fieldid in enumerate(id_list):
mags_dict[fieldid] = {k: v[ix] for k, v in sky_mags.items()}
airmass_dict[fieldid] = airmass[ix]
moon_distance_dict[fieldid] = moon_distance[ix]
hour_angle_dict[fieldid] = hour_angle[ix]
evaluated_fields = 0
discarded_fields_airmass = 0
discarded_fields_notargets = 0
discarded_targets_consecutive = 0
discarded_targets_nanbrightness = 0
discarded_targets_lowbrightness = 0
discarded_targets_highbrightness = 0
discarded_targets_seeing = 0
discarded_moon_distance = 0
evaluated_targets = 0
groups_to_close_list = []
# compute target value
for field in fields_evaluation_list:
fieldid = field.fieldid
# discard fields with no more targets tonight
if fieldid not in self.tonight_targets_dict:
discarded_fields_notargets += 1
continue
# discard fields beyond airmass limit
if self.ignore_airmass:
airmass = 1.0
else:
airmass = airmass_dict[fieldid]
if airmass > self.params.max_airmass:
discarded_fields_airmass += 1
continue
moon_distance = moon_distance_dict[fieldid]
if moon_distance < self.params.min_distance_moon_rad:
discarded_moon_distance += 1
continue
airmass_rank = self.params.airmass_bonus * \
(self.params.max_airmass - airmass) / (self.params.max_airmass - 1.0)
hour_angle_rank = self.params.hour_angle_bonus * \
(1.0 - numpy.abs(hour_angle_dict[fieldid]) / self.params.hour_angle_max_rad)
for filter in self.tonight_targets_dict[fieldid]:
lookahead_rank = lookahead.lookup_opsim(fieldid, filter) * lookahead.bonus_weight \
if lookahead is not None else 0.
if filter not in filters_evaluation_list:
continue
# discard target beyond seeing limit
if seeing > self.params.filter_max_seeing_dict[filter]:
discarded_targets_seeing += 1
continue
target = self.tonight_targets_dict[fieldid][filter]
target.time = timestamp
target.airmass = airmass
# discard target if consecutive
if self.last_observation_was_for_this_proposal:
if (self.observation_fulfills_target(
self.last_observation, target)
and not self.params.accept_consecutive_visits):
discarded_targets_consecutive += 1
continue
if self.ignore_sky_brightness:
sky_brightness = 0.0
else:
# discard target beyond sky brightness limits
sky_brightness = mags_dict[fieldid][filter]
if math.isnan(sky_brightness):
discarded_targets_nanbrightness += 1
continue
if sky_brightness < self.params.filter_min_brig_dict[
filter]:
discarded_targets_lowbrightness += 1
continue
if sky_brightness > self.params.filter_max_brig_dict[
filter]:
discarded_targets_highbrightness += 1
continue
# target is accepted
# compute value for available targets
target.sky_brightness = sky_brightness
target.cloud = cloud
target.seeing = seeing
if self.survey_targets_progress < 1.0:
area_rank = (1.0 - target.progress) / (
1.0 - self.survey_targets_progress)
if (self.params.filter_num_grouped_visits_dict[filter] >
1) and (target.groupix > 1):
time_rank = self.time_window(timestamp -
target.last_visit_time)
if time_rank > 0.0:
need_ratio = area_rank + time_rank * self.params.time_weight
else:
need_ratio = time_rank
else:
need_ratio = area_rank
else:
need_ratio = 0.0
if need_ratio > 0.0:
# target is needed
target.need = need_ratio
target.bonus = airmass_rank + hour_angle_rank + lookahead_rank
target.value = target.need + target.bonus
self.add_evaluated_target(target)
elif need_ratio < 0.0:
# target group lost
groups_to_close_list.append(target)
evaluated_targets += 1
evaluated_fields += 1
for target in groups_to_close_list:
self.close_group(target, "group lost")
self.log.log(
EXTENSIVE, "suggest_targets: fields=%i, evaluated=%i, "
"discarded airmass=%i notargets=%i" %
(len(id_list), evaluated_fields, discarded_fields_airmass,
discarded_fields_notargets))
self.log.log(
EXTENSIVE,
"suggest_targets: evaluated targets=%i, discarded consecutive=%i "
"seeing=%i "
"lowbright=%i highbright=%i nanbright=%i moondistance=%i" %
(evaluated_targets, discarded_targets_consecutive,
discarded_targets_seeing, discarded_targets_lowbrightness,
discarded_targets_highbrightness, discarded_targets_nanbrightness,
discarded_moon_distance))
return self.get_evaluated_target_list(num_targets_to_propose)
def start_night(self, timestamp, filters_mounted_tonight_list, night):
Proposal.start_night(self, timestamp, filters_mounted_tonight_list,
night)
self.fieldsvisitedtonight = {}
self.tonight_filters_list = []
self.tonight_targets = 0
self.tonight_targets_dict = {}
for filter in filters_mounted_tonight_list:
self.tonight_filters_list.append(filter)
self.build_tonight_fields_list(timestamp, night)
self.tonight_fields = len(self.tonight_fields_list)
# compute at start night
for field in self.tonight_fields_list:
fieldid = field.fieldid
# add new fields to fields dictionary
if fieldid not in self.survey_fields_dict:
self.survey_fields_dict[fieldid] = field.get_copy()
self.survey_fields += 1
# add new fields to targets dictionary
if fieldid not in self.survey_targets_dict:
self.survey_targets_dict[fieldid] = {}
self.tonight_targets_dict[fieldid] = {}
for filter in filters_mounted_tonight_list:
if filter in self.params.filter_list:
if self.params.filter_goal_dict[filter] > 0:
if filter not in self.survey_targets_dict[fieldid]:
target = Target()
target.fieldid = fieldid
target.filter = filter
target.num_exp = self.params.filter_num_exp_dict[
filter]
target.exp_times = self.params.filter_exp_times_dict[
filter]
target.ra_rad = field.ra_rad
target.dec_rad = field.dec_rad
target.propid = self.propid
target.goal = self.params.filter_goal_dict[filter]
target.visits = 0
target.progress = 0.0
target.groupid = 1
target.groupix = 1
self.survey_targets_dict[fieldid][filter] = target
self.survey_targets += 1
self.survey_targets_goal += target.goal
self.survey_filters_goal_dict[
filter] += target.goal
target = self.survey_targets_dict[fieldid][filter]
if target.progress < 1.0:
self.tonight_targets_dict[fieldid][filter] = target
self.tonight_targets += 1
for filter in self.params.filter_list:
if self.survey_filters_goal_dict[filter] > 0:
self.survey_filters_progress_dict[filter] = \
float(self.survey_filters_visits_dict[filter]) / self.survey_filters_goal_dict[filter]
else:
self.survey_filters_progress_dict[filter] = 0.0
if self.survey_targets_goal > 0:
self.survey_targets_progress = float(
self.survey_targets_visits) / self.survey_targets_goal
else:
self.survey_targets_progress = 0.0
self.log.debug("start_night tonight fields=%i targets=%i" %
(self.tonight_fields, self.tonight_targets))
self.last_observation = None
self.last_observation_was_for_this_proposal = False