starting year 1 survey

Author: yoachim

README.md

@@ -15,6 +15,7 @@ LSST observing cadence experiments
 | tight_mask | use a restrictive alt-az mask to force merdian scanning, try to force cadence (didn't work well) |
 | tight_mask_simple | Use a tight alt-az mask, only y in twilight. No 5-sigma depth used for filter selection |
 | tms_drive | tight mask, only y in twilight, no 5-sigma depth used for filter, added basis function to reward 2.1-5 day cadence in g,r,i |
-
+| tms_roll | Like tight_mask_simple, adding rolling cadence | 
+| year_1 | Work on a survey that does a good job in year 1 closing sky and gathering templates |
 
 Results at:  https://lsst-web.ncsa.illinois.edu/sim-data/beta_slair_surveys/

runs/tms_drive/tms_drive.py

@@ -43,7 +43,8 @@
                                                 norm_factor=norm_factor))
     bfs.append(fs.Slewtime_basis_function(filtername=filtername, nside=nside))
     bfs.append(fs.Strict_filter_basis_function(filtername=filtername))
-    bfs.append(fs.Cadence_enhance_basis_function(enhance_window=[2.1, 5.], nside=nside))
+    bfs.append(fs.Cadence_enhance_basis_function(enhance_window=[2.1, 5.], apply_area=cadence_area,
+                                                 nside=nside))
     bfs.append(fs.Zenith_shadow_mask_basis_function(nside=nside, shadow_minutes=60., max_alt=76.))
     bfs.append(fs.North_south_patch_basis_function(zenith_min_alt=50., zenith_pad=20.,
                                                    nside=nside))

runs/year_1/year1_surveys.py

@@ -0,0 +1,116 @@
+import numpy as np
+import lsst.sims.featureScheduler as fs
+from lsst.sims.speedObservatory import Speed_observatory
+import matplotlib.pylab as plt
+import healpy as hp
+from lsst.sims.skybrightness_pre import M5percentiles
+
+
+class Time_limit_basis_function(fs.Base_basis_function):
+    """Limit how long a survey can run with a basis function
+    """
+    def __init__(self, mjd_start=None, day_max=365.25, day_min=0,
+                 survey_features=None, condition_features=None, **kwargs):
+        """
+        Parameters
+        ----------
+        day_max : float (365.25)
+
+        """
+
+        self.mjd_start = mjd_start
+        self.day_max = day_max
+        self.day_min = day_min
+
+        if condition_features is None:
+            self.condition_features = {}
+            self.condition_features['Current_mjd'] = fs.features.Current_mjd()
+
+    def update_conditions(self, conditions):
+        for feature in self.condition_features:
+            self.condition_features[feature].update_conditions(conditions)
+        # if we haven't set a start date, use the current conditions.
+        # XXX-This might not be cold start compatible
+        if self.mjd_start is None:
+            self.mjd_start = self.condition_features['Current_mjd'].feature
+
+    def check_feasibility(self):
+
+        day = self.condition_features['Current_mjd'].feature - self.mjd_start
+        if (day > self.day_max) | (day < self.day_min):
+            result = False
+        else:
+            result = True
+        return result
+
+    def __call__(self):
+        return 0
+
+
+class Seeing_limit_basis_function(fs.Base_basis_function):
+    def __init__(self, max_seeing=1.2, filtername='r', nside=None,
+                 survey_features=None, condition_features=None, **kwargs):
+        """
+        Parameters
+        ----------
+        max_seeing : float (365.25)
+
+        """
+        if nside is None:
+            nside = fs.utils.set_default_nside()
+        self.max_seeing = max_seeing
+        self.filtername = filtername
+
+        if condition_features is None:
+            self.condition_features = {}
+            self.condition_features['Current_seeing'] = fs.features.Current_seeing(filtername=filtername,
+                                                                                   nside=nside)
+        self.result_map = np.zeros(hp.nside2npix(self.nside))
+
+    def check_feasibility(self):
+        if np.max(self()) == hp.UNSEEN:
+            return False
+        else:
+            return True
+
+    def __call__(self):
+        result = self.result_map.copy()
+        poor_seeing = np.where(self.condition_features['Current_seeing'] > self.max_seeing)
+        result[poor_seeing] = hp.UNSEEN
+        return result
+
+
+class Nvis_limit_basis_function(fs.Seeing_limit_basis_function):
+    """Shut off observations after a given number of visits
+    """
+    def __init__(self, ):
+        pass
+
+
+class Limit_m5_percentile_basis_function(fs.Seeing_limit_basis_function):
+    """
+    """
+    def __init__(self, percentile_limit=60., nside=None,
+                 survey_features=None, condition_features=None, **kwargs):
+        
+        self.m5p =  M5percentiles()
+
+    def __call__(self):
+        pass
+
+
+
+
+def year_1_surveys(nside=32, mjd0=None):
+    """
+    Generate a list of surveys for executing in year 1
+    """
+
+    filters = ['u', 'g', 'r', 'i', 'z', 'y']
+
+
+    # Don't let observations be taken in the same night--maybe just set to 13 hours or something.
+    fs.Avoid_Fast_Revists
+
+    # Maybe this would be a good time to invoke the percentile limit again! That way we won't take
+    # images in really poor depth conditions.