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