def generate_blobs(nside, nexp=1, exptime=30., filter1s=['u', 'u', 'g', 'r', 'i', 'z', 'y'],
filter2s=['g', 'r', 'r', 'i', 'z', 'y', 'y'], pair_time=22.,
camera_rot_limits=[-80., 80.], n_obs_template=3,
season=300., season_start_hour=-4., season_end_hour=2.,
shadow_minutes=60., max_alt=76., moon_distance=30., ignore_obs='DD',
m5_weight=6., footprint_weight=0.6, slewtime_weight=3.,
stayfilter_weight=3., template_weight=12., footprints=None):
"""
Generate surveys that take observations in blobs.
Parameters
----------
nside : int (32)
The HEALpix nside to use
nexp : int (1)
The number of exposures to use in a visit.
exptime : float (30.)
The exposure time to use per visit (seconds)
filter1s : list of str
The filternames for the first set
filter2s : list of str
The filter names for the second in the pair (None if unpaired)
pair_time : float (22)
The ideal time between pairs (minutes)
camera_rot_limits : list of float ([-80., 80.])
The limits to impose when rotationally dithering the camera (degrees).
n_obs_template : int (3)
The number of observations to take every season in each filter
season : float (300)
The length of season (i.e., how long before templates expire) (days)
season_start_hour : float (-4.)
For weighting how strongly a template image needs to be observed (hours)
sesason_end_hour : float (2.)
For weighting how strongly a template image needs to be observed (hours)
shadow_minutes : float (60.)
Used to mask regions around zenith (minutes)
max_alt : float (76.
The maximium altitude to use when masking zenith (degrees)
moon_distance : float (30.)
The mask radius to apply around the moon (degrees)
ignore_obs : str or list of str ('DD')
Ignore observations by surveys that include the given substring(s).
m5_weight : float (3.)
The weight for the 5-sigma depth difference basis function
footprint_weight : float (0.3)
The weight on the survey footprint basis function.
slewtime_weight : float (3.)
The weight on the slewtime basis function
stayfilter_weight : float (3.)
The weight on basis function that tries to stay avoid filter changes.
template_weight : float (12.)
The weight to place on getting image templates every season
"""
blob_survey_params = {'slew_approx': 7.5, 'filter_change_approx': 140.,
'read_approx': 2., 'min_pair_time': 15., 'search_radius': 30.,
'alt_max': 85., 'az_range': 90., 'flush_time': 30.,
'smoothing_kernel': None, 'nside': nside, 'seed': 42, 'dither': True,
'twilight_scale': True}
if footprints is None:
footprints = standard_goals(nside=nside)
sum_footprints = 0
for key in footprints:
sum_footprints += np.sum(footprints[key])
surveys = []
times_needed = [pair_time, pair_time*2]
for filtername, filtername2 in zip(filter1s, filter2s):
detailer_list = []
detailer_list.append(detailers.Camera_rot_detailer(min_rot=np.min(camera_rot_limits),
max_rot=np.max(camera_rot_limits)))
detailer_list.append(detailers.Close_alt_detailer())
# List to hold tuples of (basis_function_object, weight)
bfs = []
if filtername2 is not None:
bfs.append((bf.M5_diff_basis_function(filtername=filtername, nside=nside), m5_weight/2.))
bfs.append((bf.M5_diff_basis_function(filtername=filtername2, nside=nside), m5_weight/2.))
else:
bfs.append((bf.M5_diff_basis_function(filtername=filtername, nside=nside), m5_weight))
if filtername2 is not None:
bfs.append((bf.Footprint_basis_function(filtername=filtername,
footprint=footprints[filtername],
out_of_bounds_val=np.nan, nside=nside,
all_footprints_sum=sum_footprints), footprint_weight/2.))
bfs.append((bf.Footprint_basis_function(filtername=filtername2,
footprint=footprints[filtername2],
out_of_bounds_val=np.nan, nside=nside,
all_footprints_sum=sum_footprints), footprint_weight/2.))
else:
bfs.append((bf.Footprint_basis_function(filtername=filtername,
footprint=footprints[filtername],
out_of_bounds_val=np.nan, nside=nside,
all_footprints_sum=sum_footprints), footprint_weight))
bfs.append((bf.Slewtime_basis_function(filtername=filtername, nside=nside), slewtime_weight))
bfs.append((bf.Strict_filter_basis_function(filtername=filtername), stayfilter_weight))
if filtername2 is not None:
bfs.append((bf.N_obs_per_year_basis_function(filtername=filtername, nside=nside,
footprint=footprints[filtername],
n_obs=n_obs_template, season=season,
season_start_hour=season_start_hour,
season_end_hour=season_end_hour), template_weight/2.))
bfs.append((bf.N_obs_per_year_basis_function(filtername=filtername2, nside=nside,
footprint=footprints[filtername2],
n_obs=n_obs_template, season=season,
season_start_hour=season_start_hour,
season_end_hour=season_end_hour), template_weight/2.))
else:
bfs.append((bf.N_obs_per_year_basis_function(filtername=filtername, nside=nside,
footprint=footprints[filtername],
n_obs=n_obs_template, season=season,
season_start_hour=season_start_hour,
season_end_hour=season_end_hour), template_weight))
# Masks, give these 0 weight
bfs.append((bf.Zenith_shadow_mask_basis_function(nside=nside, shadow_minutes=shadow_minutes, max_alt=max_alt,
penalty=np.nan, site='LSST'), 0.))
bfs.append((bf.Moon_avoidance_basis_function(nside=nside, moon_distance=moon_distance), 0.))
filternames = [fn for fn in [filtername, filtername2] if fn is not None]
bfs.append((bf.Filter_loaded_basis_function(filternames=filternames), 0))
if filtername2 is None:
time_needed = times_needed[0]
else:
time_needed = times_needed[1]
bfs.append((bf.Time_to_twilight_basis_function(time_needed=time_needed), 0.))
bfs.append((bf.Not_twilight_basis_function(), 0.))
bfs.append((bf.Planet_mask_basis_function(nside=nside), 0.))
# unpack the basis functions and weights
weights = [val[1] for val in bfs]
basis_functions = [val[0] for val in bfs]
if filtername2 is None:
survey_name = 'blob, %s' % filtername
else:
survey_name = 'blob, %s%s' % (filtername, filtername2)
if filtername2 is not None:
detailer_list.append(detailers.Take_as_pairs_detailer(filtername=filtername2))
surveys.append(Blob_survey(basis_functions, weights, filtername1=filtername, filtername2=filtername2,
exptime=exptime,
ideal_pair_time=pair_time,
survey_note=survey_name, ignore_obs=ignore_obs,
nexp=nexp, detailers=detailer_list, **blob_survey_params))
return surveys
def gen_greedy_surveys(nside=32, nexp=1, exptime=30., filters=['r', 'i', 'z', 'y'],
camera_rot_limits=[-80., 80.],
shadow_minutes=60., max_alt=76., moon_distance=30., ignore_obs='DD',
m5_weight=3., footprint_weight=0.3, slewtime_weight=3.,
stayfilter_weight=3., footprints=None):
"""
Make a quick set of greedy surveys
This is a convienence function to generate a list of survey objects that can be used with
lsst.sims.featureScheduler.schedulers.Core_scheduler.
To ensure we are robust against changes in the sims_featureScheduler codebase, all kwargs are
explicitly set.
Parameters
----------
nside : int (32)
The HEALpix nside to use
nexp : int (1)
The number of exposures to use in a visit.
exptime : float (30.)
The exposure time to use per visit (seconds)
filters : list of str (['r', 'i', 'z', 'y'])
Which filters to generate surveys for.
camera_rot_limits : list of float ([-80., 80.])
The limits to impose when rotationally dithering the camera (degrees).
shadow_minutes : float (60.)
Used to mask regions around zenith (minutes)
max_alt : float (76.
The maximium altitude to use when masking zenith (degrees)
moon_distance : float (30.)
The mask radius to apply around the moon (degrees)
ignore_obs : str or list of str ('DD')
Ignore observations by surveys that include the given substring(s).
m5_weight : float (3.)
The weight for the 5-sigma depth difference basis function
footprint_weight : float (0.3)
The weight on the survey footprint basis function.
slewtime_weight : float (3.)
The weight on the slewtime basis function
stayfilter_weight : float (3.)
The weight on basis function that tries to stay avoid filter changes.
"""
# Define the extra parameters that are used in the greedy survey. I
# think these are fairly set, so no need to promote to utility func kwargs
greed_survey_params = {'block_size': 1, 'smoothing_kernel': None,
'seed': 42, 'camera': 'LSST', 'dither': True,
'survey_name': 'greedy'}
if footprints is None:
footprints = standard_goals(nside=nside)
sum_footprints = 0
for key in footprints:
sum_footprints += np.sum(footprints[key])
surveys = []
detailer = detailers.Camera_rot_detailer(min_rot=np.min(camera_rot_limits), max_rot=np.max(camera_rot_limits))
for filtername in filters:
bfs = []
bfs.append((bf.M5_diff_basis_function(filtername=filtername, nside=nside), m5_weight))
bfs.append((bf.Footprint_basis_function(filtername=filtername,
footprint=footprints[filtername],
out_of_bounds_val=np.nan, nside=nside,
all_footprints_sum=sum_footprints), footprint_weight))
bfs.append((bf.Slewtime_basis_function(filtername=filtername, nside=nside), slewtime_weight))
bfs.append((bf.Strict_filter_basis_function(filtername=filtername), stayfilter_weight))
# Masks, give these 0 weight
bfs.append((bf.Zenith_shadow_mask_basis_function(nside=nside, shadow_minutes=shadow_minutes,
max_alt=max_alt), 0))
bfs.append((bf.Moon_avoidance_basis_function(nside=nside, moon_distance=moon_distance), 0))
bfs.append((bf.Filter_loaded_basis_function(filternames=filtername), 0))
bfs.append((bf.Planet_mask_basis_function(nside=nside), 0))
weights = [val[1] for val in bfs]
basis_functions = [val[0] for val in bfs]
surveys.append(Greedy_survey(basis_functions, weights, exptime=exptime, filtername=filtername,
nside=nside, ignore_obs=ignore_obs, nexp=nexp,
detailers=[detailer], **greed_survey_params))
return surveys
try:
extra_info['git hash'] = subprocess.check_output(
['git', 'rev-parse', 'HEAD'])
except subprocess.CalledProcessError:
extra_info['git hash'] = 'Not in git repo'
extra_info['file executed'] = os.path.realpath(__file__)
fileroot = 'goodseeing_%s_' % good_seeing_filts
file_end = 'v1.5_'
# Set up the DDF surveys to dither
dither_detailer = detailers.Dither_detailer(per_night=per_night,
max_dither=max_dither)
details = [
detailers.Camera_rot_detailer(min_rot=-camera_ddf_rot_limit,
max_rot=camera_ddf_rot_limit),
dither_detailer
]
ddfs = generate_dd_surveys(nside=nside, nexp=nexp, detailers=details)
greedy = gen_greedy_surveys(nside, nexp=nexp)
blobs = generate_blobs(nside,
nexp=nexp,
good_seeing_filts=good_seeing_filts)
surveys = [ddfs, blobs, greedy]
run_sched(surveys,
survey_length=survey_length,
verbose=verbose,
fileroot=os.path.join(outDir, fileroot + file_end),
extra_info=extra_info,
nside=nside,
try:
extra_info['git hash'] = subprocess.check_output(['git', 'rev-parse', 'HEAD'])
except subprocess.CalledProcessError:
extra_info['git hash'] = 'Not in git repo'
extra_info['file executed'] = os.path.realpath(__file__)
fileroot = 'ddf_ahead_%i_' % float_time
file_end = 'v1.6_'
if scale_down:
footprints = nes_light_footprints(nside=nside)
fileroot = fileroot +'scaleddown_'
else:
footprints = standard_goals(nside=nside)
# Set up the DDF surveys to dither
dither_detailer = detailers.Dither_detailer(per_night=per_night, max_dither=max_dither)
details = [detailers.Camera_rot_detailer(min_rot=-camera_ddf_rot_limit, max_rot=camera_ddf_rot_limit), dither_detailer]
ddf_dict, ha_dict = ddf_info()
ddf_times = read_times(filename=ddf_file, end_time=float_time)
ddfs = [Scheduled_ddfs(ddf_times, ddf_dict, ha_dict, detailers=details)]
greedy = gen_greedy_surveys(nside, nexp=nexp, footprints=footprints)
blobs = generate_blobs(nside, nexp=nexp, footprints=footprints)
surveys = [ddfs, blobs, greedy]
run_sched(surveys, survey_length=survey_length, verbose=verbose,
fileroot=os.path.join(outDir, fileroot+file_end), extra_info=extra_info,
nside=nside, illum_limit=illum_limit)
extra_info['file executed'] = os.path.realpath(__file__)
fileroot = 'dcr_nham%i_' % nham
file_end = 'v1.3_'
observatory = Model_observatory(nside=nside)
conditions = observatory.return_conditions()
# Mark position of the sun at the start of the survey. Usefull for rolling cadence.
sun_ra_0 = conditions.sunRA # radians
offset = create_season_offset(nside, sun_ra_0) + 365.25
# Set up the DDF surveys to dither
dither_detailer = detailers.Dither_detailer(per_night=per_night,
max_dither=max_dither)
details = [
detailers.Camera_rot_detailer(min_rot=-87., max_rot=87.),
dither_detailer
]
ddfs = generate_dd_surveys(nside=nside, nexp=nexp, detailers=details)
if Pairs:
if mixedPairs:
greedy = gen_greedy_surveys(nside, nexp=nexp)
blobs = generate_blobs(nside,
nexp=nexp,
mixed_pairs=True,
offset=offset)
high_am = generate_high_am(nside, nexp=nexp, n_high_am=nham)
blobs.extend(high_am)
surveys = [ddfs, blobs, greedy]
run_sched(surveys,
def generate_blobs(nside,
mixed_pairs=False,
nexp=1,
no_pairs=False,
offset=None,
template_weight=6.):
target_map = standard_goals(nside=nside)
norm_factor = calc_norm_factor(target_map)
# List to hold all the surveys (for easy plotting later)
surveys = []
# Set up observations to be taken in blocks
filter1s = ['u', 'g', 'r', 'i', 'z', 'y']
if mixed_pairs:
filter2s = [None, 'r', 'i', 'z', None, None]
else:
filter2s = [None, 'g', 'r', 'i', None, None]
if no_pairs:
filter2s = [None, None, None, None, None, None]
# Ideal time between taking pairs
pair_time = 22.
times_needed = [pair_time, pair_time * 2]
for filtername, filtername2 in zip(filter1s, filter2s):
detailer_list = []
detailer_list.append(
detailers.Camera_rot_detailer(min_rot=-87., max_rot=87.))
detailer_list.append(detailers.Close_alt_detailer())
bfs = []
bfs.append(
bf.M5_diff_basis_function(filtername=filtername, nside=nside))
if filtername2 is not None:
bfs.append(
bf.M5_diff_basis_function(filtername=filtername2, nside=nside))
bfs.append(
bf.Target_map_basis_function(filtername=filtername,
target_map=target_map[filtername],
out_of_bounds_val=np.nan,
nside=nside,
norm_factor=norm_factor))
if filtername2 is not None:
bfs.append(
bf.Target_map_basis_function(
filtername=filtername2,
target_map=target_map[filtername2],
out_of_bounds_val=np.nan,
nside=nside,
norm_factor=norm_factor))
bfs.append(
bf.Slewtime_basis_function(filtername=filtername, nside=nside))
bfs.append(bf.Strict_filter_basis_function(filtername=filtername))
bfs.append(
bf.N_obs_per_year_basis_function(filtername=filtername,
nside=nside,
footprint=target_map[filtername],
n_obs=3,
season=300.))
if filtername2 is not None:
bfs.append(
bf.N_obs_per_year_basis_function(
filtername=filtername2,
nside=nside,
footprint=target_map[filtername2],
n_obs=3,
season=300.))
# Masks, give these 0 weight
bfs.append(
bf.Zenith_shadow_mask_basis_function(nside=nside,
shadow_minutes=60.,
max_alt=76.))
bfs.append(
bf.Moon_avoidance_basis_function(nside=nside, moon_distance=30.))
filternames = [
fn for fn in [filtername, filtername2] if fn is not None
]
bfs.append(bf.Filter_loaded_basis_function(filternames=filternames))
if filtername2 is None:
time_needed = times_needed[0]
else:
time_needed = times_needed[1]
bfs.append(bf.Time_to_twilight_basis_function(time_needed=time_needed))
bfs.append(bf.Not_twilight_basis_function())
bfs.append(bf.Planet_mask_basis_function(nside=nside))
weights = np.array([
3.0, 3.0, .3, .3, 3., 3., template_weight, template_weight, 0., 0.,
0., 0., 0., 0.
])
if filtername2 is None:
# Need to scale weights up so filter balancing still works properly.
weights = np.array([
6.0, 0.6, 3., 3., template_weight * 2, 0., 0., 0., 0., 0., 0.
])
if filtername2 is None:
survey_name = 'blob, %s' % filtername
else:
survey_name = 'blob, %s%s' % (filtername, filtername2)
if filtername2 is not None:
detailer_list.append(
detailers.Take_as_pairs_detailer(filtername=filtername2))
surveys.append(
Blob_survey(bfs,
weights,
filtername1=filtername,
filtername2=filtername2,
ideal_pair_time=pair_time,
nside=nside,
survey_note=survey_name,
ignore_obs=['DD', 'high_am'],
dither=True,
nexp=nexp,
detailers=detailer_list))
return surveys
def generate_high_am(nside,
nexp=1,
n_high_am=2,
hair_weight=6.,
pair_time=22.,
camera_rot_limits=[-80., 80.],
season=300.,
season_start_hour=-4.,
season_end_hour=2.,
shadow_minutes=60.,
max_alt=76.,
moon_distance=30.,
ignore_obs='DD',
m5_weight=6.,
footprint_weight=0.6,
slewtime_weight=3.,
stayfilter_weight=3.,
template_weight=12.,
const_weight=1,
min_area=288.):
"""Let's set this up like the blob, but then give it a little extra weight.
"""
target_maps = standard_goals(nside=nside)
filters = ['u', 'g']
surveys = []
for filtername in filters:
survey_name = 'high_am, %s' % filtername
target_map = target_maps[filtername] * 0
target_map[np.where(
target_maps[filtername] == np.max(target_maps[filtername]))] = 1.
detailer_list = []
detailer_list.append(
detailers.Camera_rot_detailer(min_rot=np.min(camera_rot_limits),
max_rot=np.max(camera_rot_limits)))
detailer_list.append(detailers.Close_alt_detailer())
bfs = []
bfs.append((bf.M5_diff_basis_function(filtername=filtername,
nside=nside), m5_weight))
bfs.append((bf.Slewtime_basis_function(filtername=filtername,
nside=nside), slewtime_weight))
bfs.append((bf.Strict_filter_basis_function(filtername=filtername),
slewtime_weight))
bfs.append((bf.N_obs_high_am_basis_function(nside=nside,
footprint=target_map,
filtername=filtername,
n_obs=n_high_am,
season=season,
out_of_bounds_val=np.nan),
hair_weight))
bfs.append((bf.Constant_basis_function(), const_weight))
# Masks, give these 0 weight
bfs.append((bf.Zenith_shadow_mask_basis_function(
nside=nside,
shadow_minutes=shadow_minutes,
max_alt=max_alt,
penalty=np.nan,
site='LSST'), 0.))
bfs.append(
(bf.Moon_avoidance_basis_function(nside=nside,
moon_distance=moon_distance),
0.))
bfs.append(
(bf.Filter_loaded_basis_function(filternames=filtername), 0))
bfs.append(
(bf.Time_to_twilight_basis_function(time_needed=pair_time), 0.))
bfs.append((bf.Not_twilight_basis_function(), 0.))
bfs.append((bf.Planet_mask_basis_function(nside=nside), 0.))
weights = [val[1] for val in bfs]
basis_functions = [val[0] for val in bfs]
surveys.append(
Blob_survey(basis_functions,
weights,
filtername1=filtername,
filtername2=None,
ideal_pair_time=pair_time,
nside=nside,
survey_note=survey_name,
ignore_obs=ignore_obs,
dither=True,
nexp=nexp,
detailers=detailer_list,
min_area=min_area))
return surveys
extra_info['git hash'] = subprocess.check_output(['git', 'rev-parse', 'HEAD'])
extra_info['file executed'] = os.path.realpath(__file__)
fileroot = 'delayedrolling_mod%i_sdf_%.2f_' % (mod_year, scale_down_factor)
file_end = 'v1.3_'
observatory = Model_observatory(nside=nside)
conditions = observatory.return_conditions()
# Mark position of the sun at the start of the survey. Usefull for rolling cadence.
sun_ra_0 = conditions.sunRA # radians
offset = create_season_offset(nside, sun_ra_0)
max_season = 6
# Set up the DDF surveys to dither
dither_detailer = detailers.Dither_detailer(per_night=per_night, max_dither=max_dither)
details = [detailers.Camera_rot_detailer(min_rot=-87., max_rot=87.), dither_detailer]
ddfs = generate_dd_surveys(nside=nside, nexp=nexp, detailers=details)
sg = standard_goals()
norm_factor = calc_norm_factor(sg)
roll_maps = slice_wfd_area(mod_year, sg, scale_down_factor=scale_down_factor)
target_maps = roll_maps + [sg]
if Pairs:
if mixedPairs:
greedy = gen_greedy_surveys(nside, nexp=nexp, target_maps=target_maps, mod_year=mod_year, day_offset=offset,
norm_factor=norm_factor, max_season=max_season)
blobs = generate_blobs(nside, nexp=nexp, mixed_pairs=True, offset=offset, target_maps=target_maps,
norm_factor=norm_factor, mod_year=mod_year, max_season=max_season, day_offset=offset)
surveys = [ddfs, blobs, greedy]
run_sched(surveys, survey_length=survey_length, verbose=verbose,
def gen_greedy_surveys(nside,
nexp=1,
target_maps=None,
mod_year=None,
day_offset=None,
norm_factor=None,
max_season=10):
"""
Make a quick set of greedy surveys
"""
target_map = standard_goals(nside=nside)
norm_factor = calc_norm_factor(target_map)
wfd_halves = wfd_half()
# Let's remove the bluer filters since this should only be near twilight
filters = ['r', 'i', 'z', 'y']
surveys = []
detailer = detailers.Camera_rot_detailer(min_rot=-87., max_rot=87.)
for filtername in filters:
bfs = []
bfs.append(
bf.M5_diff_basis_function(filtername=filtername, nside=nside))
target_list = [tm[filtername] for tm in target_maps]
bfs.append(
bf.Target_map_modulo_basis_function(filtername=filtername,
target_maps=target_list,
season_modulo=mod_year,
day_offset=day_offset,
out_of_bounds_val=np.nan,
nside=nside,
norm_factor=norm_factor,
max_season=max_season))
bfs.append(
bf.Slewtime_basis_function(filtername=filtername, nside=nside))
bfs.append(bf.Strict_filter_basis_function(filtername=filtername))
bfs.append(bf.Map_modulo_basis_function(wfd_halves))
# Masks, give these 0 weight
bfs.append(
bf.Zenith_shadow_mask_basis_function(nside=nside,
shadow_minutes=60.,
max_alt=76.))
bfs.append(
bf.Moon_avoidance_basis_function(nside=nside, moon_distance=40.))
bfs.append(bf.Filter_loaded_basis_function(filternames=filtername))
bfs.append(bf.Planet_mask_basis_function(nside=nside))
weights = np.array([3.0, 0.3, 3., 3., 3., 0., 0., 0., 0.])
surveys.append(
Greedy_survey(bfs,
weights,
block_size=1,
filtername=filtername,
dither=True,
nside=nside,
ignore_obs='DD',
nexp=nexp,
detailers=[detailer]))
return surveys
def generate_twilight_neo(nside, night_pattern=None):
surveys = []
nexp = 1
filters = 'riz'
survey_name = 'twilight_neo'
target_map_one = ecliptic_target(nside=nside)
target_map = {}
for filtername in filters:
target_map[filtername] = target_map_one
norm_factor = calc_norm_factor(target_map)
exptime = 1.
for filtername in filters:
detailer_list = []
detailer_list.append(
detailers.Camera_rot_detailer(min_rot=-87., max_rot=87.))
detailer_list.append(detailers.Close_alt_detailer())
detailer_list.append(
detailers.Twilight_triple_detailer(slew_estimate=4.5, n_repeat=3))
bfs = []
bfs.append(
bf.Target_map_basis_function(filtername=filtername,
target_map=target_map[filtername],
out_of_bounds_val=np.nan,
nside=nside,
norm_factor=norm_factor))
bfs.append(
bf.Slewtime_basis_function(filtername=filtername, nside=nside))
bfs.append(bf.Strict_filter_basis_function(filtername=filtername))
# XXX
# Need a toward the sun, reward high airmass, with an airmass cutoff basis function.
bfs.append(
bf.Near_sun_twilight_basis_function(nside=nside, max_airmass=2.))
bfs.append(
bf.Zenith_shadow_mask_basis_function(nside=nside,
shadow_minutes=60.,
max_alt=76.))
bfs.append(
bf.Moon_avoidance_basis_function(nside=nside, moon_distance=30.))
bfs.append(bf.Filter_loaded_basis_function(filternames=filtername))
bfs.append(bf.Planet_mask_basis_function(nside=nside))
bfs.append(bf.Sun_alt_limit_basis_function())
bfs.append(bf.Time_in_twilight_basis_function(time_needed=5.))
bfs.append(bf.Night_modulo_basis_function(pattern=night_pattern))
weights = [0.1, 3., 3., 3., 0., 0., 0., 0., 0., 0., 0.]
# Set huge ideal pair time and use the detailer to cut down the list of observations to fit twilight?
surveys.append(
Blob_survey(bfs,
weights,
filtername1=filtername,
filtername2=None,
ideal_pair_time=3.,
nside=nside,
exptime=exptime,
survey_note=survey_name,
ignore_obs=['DD', 'greedy', 'blob'],
dither=True,
nexp=nexp,
detailers=detailer_list,
az_range=180.,
twilight_scale=False))
return surveys
def generate_twilight_neo(nside,
night_pattern=None,
nexp=1,
exptime=1,
camera_rot_limits=[-80., 80.],
footprint_weight=0.1,
slewtime_weight=3.,
stayfilter_weight=3.,
mjd_start=0,
sun_RA_start=0.):
# XXX finish eliminating magic numbers and document this one
slew_estimate = 4.5
filters = 'riz'
survey_name = 'twilight_neo'
footprint = ecliptic_target(nside=nside)
footprints_hp = {}
for filtername in filters:
footprints_hp[filtername] = footprint
footprints = Footprint(mjd_start, sun_RA_start=sun_RA_start, nside=nside)
for i, key in enumerate(footprints_hp):
footprints.footprints[i, :] = footprints_hp[key]
surveys = []
for filtername in filters:
detailer_list = []
detailer_list.append(
detailers.Camera_rot_detailer(min_rot=np.min(camera_rot_limits),
max_rot=np.max(camera_rot_limits)))
detailer_list.append(detailers.Close_alt_detailer())
detailer_list.append(
detailers.Twilight_triple_detailer(slew_estimate=slew_estimate,
n_repeat=3))
bfs = []
bfs.append(
(bf.Footprint_basis_function(filtername=filtername,
footprint=footprints,
out_of_bounds_val=np.nan,
nside=nside), footprint_weight))
bfs.append((bf.Slewtime_basis_function(filtername=filtername,
nside=nside), slewtime_weight))
bfs.append((bf.Strict_filter_basis_function(filtername=filtername),
stayfilter_weight))
# Need a toward the sun, reward high airmass, with an airmass cutoff basis function.
bfs.append((bf.Near_sun_twilight_basis_function(nside=nside,
max_airmass=2.), 0))
bfs.append((bf.Zenith_shadow_mask_basis_function(nside=nside,
shadow_minutes=60.,
max_alt=76.), 0))
bfs.append((bf.Moon_avoidance_basis_function(nside=nside,
moon_distance=30.), 0))
bfs.append(
(bf.Filter_loaded_basis_function(filternames=filtername), 0))
bfs.append((bf.Planet_mask_basis_function(nside=nside), 0))
bfs.append((bf.Sun_alt_limit_basis_function(), 0))
bfs.append((bf.Time_in_twilight_basis_function(time_needed=5.), 0))
bfs.append((bf.Night_modulo_basis_function(pattern=night_pattern), 0))
# unpack the basis functions and weights
weights = [val[1] for val in bfs]
basis_functions = [val[0] for val in bfs]
# Set huge ideal pair time and use the detailer to cut down the list of observations to fit twilight?
surveys.append(
Blob_survey(basis_functions,
weights,
filtername1=filtername,
filtername2=None,
ideal_pair_time=3.,
nside=nside,
exptime=exptime,
survey_note=survey_name,
ignore_obs=['DD', 'greedy', 'blob'],
dither=True,
nexp=nexp,
detailers=detailer_list,
az_range=180.,
twilight_scale=False))
return surveys
