diff --git a/docs/check.html b/docs/check.html
index 8a2a488..545ba02 100644
--- a/docs/check.html
+++ b/docs/check.html
@@ -53,7 +53,7 @@ <h1 class="title">Module <code>deeplenstronomy.check</code></h1>
     exec(f&#39;import lenstronomy.LensModel.Profiles.{model} as {model}_lens&#39;)
 
 
-from deeplenstronomy.utils import KeyPathDict
+from deeplenstronomy.utils import KeyPathDict, read_cadence_file
 import deeplenstronomy.distributions as distributions
 
 class ConfigFileError(Exception): pass
@@ -838,9 +838,12 @@ <h1 class="title">Module <code>deeplenstronomy.check</code></h1>
                         errs.append(&#39;GEOMETRY.&#39; + k + &#39;.&#39; + config_k + &#39; needs a valid integer index greater than zero&#39;)
 
                     # Plane must have a redshift
-                    if &#39;REDSHIFT&#39; not in config_k in self.config[&#39;GEOMETRY&#39;][k][config_k][&#39;PARAMETERS&#39;].keys():
-                        errs.append(&#39;REDSHIFT is missing from GEOMETRY.&#39; + k + &#39;.&#39; + config_k)
-
+                    try:
+                        if &#39;REDSHIFT&#39; not in self.config[&#39;GEOMETRY&#39;][k][config_k][&#39;PARAMETERS&#39;].keys():
+                            errs.append(&#39;REDSHIFT is missing from GEOMETRY.&#39; + k + &#39;.&#39; + config_k)
+                    except AttributeError:
+                        errs.append(&#39;Incorrect format detected in &#39; + k + &#39;.&#39; + config_k)
+                        
                     detected_objects = []
                     for obj_k in self.config[&#39;GEOMETRY&#39;][k][config_k].keys():
                         # check individual object properties
@@ -913,15 +916,43 @@ <h1 class="title">Module <code>deeplenstronomy.check</code></h1>
                     if &#34;NITES&#34; not in self.config[&#39;GEOMETRY&#39;][k][config_k].keys():
                         errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES is missing the NITES parameter&#34;)
                     else:
-                        if not isinstance(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;], list):
-                            errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES must be a list&#34;)
+                        if not (isinstance(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;], list) or isinstance(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;], str)):
+                            errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES must be a list or a filename&#34;)
                         else:
-                            # listed nights must be numeric
-                            try:
-                                nites = [int(float(x)) for x in self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;]]
-                                del nites
-                            except TypeError:
-                                errs.append(&#34;Listed NITES in GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES must be numeric&#34;)
+                            if isinstance(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;], list):
+                                nitelists = [self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;]]
+                            else:
+                                # filename of cadence file
+                                try:
+                                    cadence_dict = read_cadence_file(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;])
+
+                                    # Pointings must be incrementally sequenced
+                                    nitelists = []
+                                    bands = set(self.config[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;].strip().split(&#39;,&#39;))
+                                    pointings = [x for x in cadence_dict.keys() if x.startswith(&#39;POINTING_&#39;)]
+                                    if len(pointings) == 0:
+                                        errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES.&#34; + self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;] + &#34; contains no POINTING entries&#34;)
+                                    for pointing in pointings:
+                                        if set(list(cadence_dict[pointing].keys())) != bands:
+                                            errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES.&#34; + self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;] + pointing + &#34; does not contain same bands as the survey&#34;)
+                                        else:
+                                            cad_length = len(cadence_dict[pointing][self.config[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;].strip().split(&#39;,&#39;)[0]])
+                                            for band in bands:
+                                                if len(cadence_dict[pointing][band]) != cad_length:
+                                                    errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES.&#34; + self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;] + pointing + &#34; contains cadences of different lengths&#34;)
+                                                nitelists.append(cadence_dict[pointing][band])
+                                    
+                                except Exception:
+                                    errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES.&#34; + self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;] + &#34; caused an error when reading file&#34;)
+                                    nitelists = [[]]
+                                    
+                            for nitelist in nitelists:
+                                # listed nights must be numeric
+                                try:
+                                    nites = [int(float(x)) for x in nitelist]
+                                    del nites
+                                except TypeError:
+                                    errs.append(&#34;Listed NITES in GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES must be numeric&#34;)
 
                     # Check validity of PEAK argument, if passed
                     if &#34;PEAK&#34; in self.config[&#39;GEOMETRY&#39;][k][config_k].keys():
@@ -1800,9 +1831,12 @@ <h2 class="section-title" id="header-classes">Classes</h2>
                         errs.append(&#39;GEOMETRY.&#39; + k + &#39;.&#39; + config_k + &#39; needs a valid integer index greater than zero&#39;)
 
                     # Plane must have a redshift
-                    if &#39;REDSHIFT&#39; not in config_k in self.config[&#39;GEOMETRY&#39;][k][config_k][&#39;PARAMETERS&#39;].keys():
-                        errs.append(&#39;REDSHIFT is missing from GEOMETRY.&#39; + k + &#39;.&#39; + config_k)
-
+                    try:
+                        if &#39;REDSHIFT&#39; not in self.config[&#39;GEOMETRY&#39;][k][config_k][&#39;PARAMETERS&#39;].keys():
+                            errs.append(&#39;REDSHIFT is missing from GEOMETRY.&#39; + k + &#39;.&#39; + config_k)
+                    except AttributeError:
+                        errs.append(&#39;Incorrect format detected in &#39; + k + &#39;.&#39; + config_k)
+                        
                     detected_objects = []
                     for obj_k in self.config[&#39;GEOMETRY&#39;][k][config_k].keys():
                         # check individual object properties
@@ -1875,15 +1909,43 @@ <h2 class="section-title" id="header-classes">Classes</h2>
                     if &#34;NITES&#34; not in self.config[&#39;GEOMETRY&#39;][k][config_k].keys():
                         errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES is missing the NITES parameter&#34;)
                     else:
-                        if not isinstance(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;], list):
-                            errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES must be a list&#34;)
+                        if not (isinstance(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;], list) or isinstance(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;], str)):
+                            errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES must be a list or a filename&#34;)
                         else:
-                            # listed nights must be numeric
-                            try:
-                                nites = [int(float(x)) for x in self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;]]
-                                del nites
-                            except TypeError:
-                                errs.append(&#34;Listed NITES in GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES must be numeric&#34;)
+                            if isinstance(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;], list):
+                                nitelists = [self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;]]
+                            else:
+                                # filename of cadence file
+                                try:
+                                    cadence_dict = read_cadence_file(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;])
+
+                                    # Pointings must be incrementally sequenced
+                                    nitelists = []
+                                    bands = set(self.config[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;].strip().split(&#39;,&#39;))
+                                    pointings = [x for x in cadence_dict.keys() if x.startswith(&#39;POINTING_&#39;)]
+                                    if len(pointings) == 0:
+                                        errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES.&#34; + self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;] + &#34; contains no POINTING entries&#34;)
+                                    for pointing in pointings:
+                                        if set(list(cadence_dict[pointing].keys())) != bands:
+                                            errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES.&#34; + self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;] + pointing + &#34; does not contain same bands as the survey&#34;)
+                                        else:
+                                            cad_length = len(cadence_dict[pointing][self.config[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;].strip().split(&#39;,&#39;)[0]])
+                                            for band in bands:
+                                                if len(cadence_dict[pointing][band]) != cad_length:
+                                                    errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES.&#34; + self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;] + pointing + &#34; contains cadences of different lengths&#34;)
+                                                nitelists.append(cadence_dict[pointing][band])
+                                    
+                                except Exception:
+                                    errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES.&#34; + self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;] + &#34; caused an error when reading file&#34;)
+                                    nitelists = [[]]
+                                    
+                            for nitelist in nitelists:
+                                # listed nights must be numeric
+                                try:
+                                    nites = [int(float(x)) for x in nitelist]
+                                    del nites
+                                except TypeError:
+                                    errs.append(&#34;Listed NITES in GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES must be numeric&#34;)
 
                     # Check validity of PEAK argument, if passed
                     if &#34;PEAK&#34; in self.config[&#39;GEOMETRY&#39;][k][config_k].keys():
@@ -2372,9 +2434,12 @@ <h3>Methods</h3>
                     errs.append(&#39;GEOMETRY.&#39; + k + &#39;.&#39; + config_k + &#39; needs a valid integer index greater than zero&#39;)
 
                 # Plane must have a redshift
-                if &#39;REDSHIFT&#39; not in config_k in self.config[&#39;GEOMETRY&#39;][k][config_k][&#39;PARAMETERS&#39;].keys():
-                    errs.append(&#39;REDSHIFT is missing from GEOMETRY.&#39; + k + &#39;.&#39; + config_k)
-
+                try:
+                    if &#39;REDSHIFT&#39; not in self.config[&#39;GEOMETRY&#39;][k][config_k][&#39;PARAMETERS&#39;].keys():
+                        errs.append(&#39;REDSHIFT is missing from GEOMETRY.&#39; + k + &#39;.&#39; + config_k)
+                except AttributeError:
+                    errs.append(&#39;Incorrect format detected in &#39; + k + &#39;.&#39; + config_k)
+                    
                 detected_objects = []
                 for obj_k in self.config[&#39;GEOMETRY&#39;][k][config_k].keys():
                     # check individual object properties
@@ -2447,15 +2512,43 @@ <h3>Methods</h3>
                 if &#34;NITES&#34; not in self.config[&#39;GEOMETRY&#39;][k][config_k].keys():
                     errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES is missing the NITES parameter&#34;)
                 else:
-                    if not isinstance(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;], list):
-                        errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES must be a list&#34;)
+                    if not (isinstance(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;], list) or isinstance(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;], str)):
+                        errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES must be a list or a filename&#34;)
                     else:
-                        # listed nights must be numeric
-                        try:
-                            nites = [int(float(x)) for x in self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;]]
-                            del nites
-                        except TypeError:
-                            errs.append(&#34;Listed NITES in GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES must be numeric&#34;)
+                        if isinstance(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;], list):
+                            nitelists = [self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;]]
+                        else:
+                            # filename of cadence file
+                            try:
+                                cadence_dict = read_cadence_file(self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;])
+
+                                # Pointings must be incrementally sequenced
+                                nitelists = []
+                                bands = set(self.config[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;].strip().split(&#39;,&#39;))
+                                pointings = [x for x in cadence_dict.keys() if x.startswith(&#39;POINTING_&#39;)]
+                                if len(pointings) == 0:
+                                    errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES.&#34; + self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;] + &#34; contains no POINTING entries&#34;)
+                                for pointing in pointings:
+                                    if set(list(cadence_dict[pointing].keys())) != bands:
+                                        errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES.&#34; + self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;] + pointing + &#34; does not contain same bands as the survey&#34;)
+                                    else:
+                                        cad_length = len(cadence_dict[pointing][self.config[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;].strip().split(&#39;,&#39;)[0]])
+                                        for band in bands:
+                                            if len(cadence_dict[pointing][band]) != cad_length:
+                                                errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES.&#34; + self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;] + pointing + &#34; contains cadences of different lengths&#34;)
+                                            nitelists.append(cadence_dict[pointing][band])
+                                
+                            except Exception:
+                                errs.append(&#34;GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES.&#34; + self.config[&#39;GEOMETRY&#39;][k][config_k][&#34;NITES&#34;] + &#34; caused an error when reading file&#34;)
+                                nitelists = [[]]
+                                
+                        for nitelist in nitelists:
+                            # listed nights must be numeric
+                            try:
+                                nites = [int(float(x)) for x in nitelist]
+                                del nites
+                            except TypeError:
+                                errs.append(&#34;Listed NITES in GEOMETRY.&#34; + k + &#34;.TIMESERIES.NITES must be numeric&#34;)
 
                 # Check validity of PEAK argument, if passed
                 if &#34;PEAK&#34; in self.config[&#39;GEOMETRY&#39;][k][config_k].keys():
diff --git a/docs/input_reader.html b/docs/input_reader.html
index e4d41d1..2b58d3c 100644
--- a/docs/input_reader.html
+++ b/docs/input_reader.html
@@ -39,7 +39,7 @@ <h1 class="title">Module <code>deeplenstronomy.input_reader</code></h1>
 import numpy as np
 
 import deeplenstronomy.timeseries as timeseries
-from deeplenstronomy.utils import dict_select, dict_select_choose, draw_from_user_dist, KeyPathDict
+from deeplenstronomy.utils import dict_select, dict_select_choose, draw_from_user_dist, KeyPathDict, read_cadence_file
 import deeplenstronomy.distributions as distributions
 import deeplenstronomy.special as special
 import deeplenstronomy.surveys as surveys
@@ -316,6 +316,11 @@ <h1 class="title">Module <code>deeplenstronomy.input_reader</code></h1>
         #Object IDs
         for band in bands:
             output_dict[band][&#39;OBJID&#39;] = objid
+
+        #Pointing
+        pointing = random.choice(list(set(self.cadence_dict.keys()) - set([&#39;REFERENCE_MJD&#39;])))
+        for band in bands:
+            output_dict[band][&#39;POINTING&#39;] = pointing
         
         #COSMOLOGY
         for k, v in config_dict[&#39;COSMOLOGY_DICT&#39;].items():
@@ -550,18 +555,22 @@ <h1 class="title">Module <code>deeplenstronomy.input_reader</code></h1>
         # Get flattened and filled dictionary
         base_output_dict = self._flatten_and_fill(config_dict, cosmo, objid)
 
+        pointing = base_output_dict[bands[0]][&#39;POINTING&#39;]
         closest_redshift_lcs = []
         for obj_name, obj_string in zip(self.main_dict[&#39;GEOMETRY&#39;][configuration][&#39;TIMESERIES&#39;][&#39;OBJECTS&#39;], obj_strings):
             # determine closest lc in library to redshift
             redshift = base_output_dict[bands[0]][obj_string + &#39;-REDSHIFT&#39;]
-            lcs = eval(&#39;self.{0}_{1}_lightcurves&#39;.format(configuration, obj_name))
+            lcs = eval(&#39;self.{0}_{1}_lightcurves_{2}&#39;.format(configuration, obj_name, pointing))
             closest_redshift_lcs.append(lcs[&#39;library&#39;][np.argmin(np.abs(redshift - lcs[&#39;redshifts&#39;]))])
             
-        # overwrite the image sim dictionary        
-        for orig_nite in self.main_dict[&#39;GEOMETRY&#39;][configuration][&#39;TIMESERIES&#39;][&#39;NITES&#39;]:
-            nite = orig_nite - peakshift
-            output_dict = base_output_dict.copy()
+        # overwrite the image sim dictionary
+        nite_dict = self.cadence_dict[pointing]
+        for nite_idx in range(len(nite_dict[bands[0]])):
             for band in bands:
+                orig_nite = nite_dict[band][nite_idx]
+                #for orig_nite in nite_dict[band]:
+                nite = orig_nite - peakshift
+                output_dict = base_output_dict.copy()
                 for obj_sting, closest_redshift_lc in zip(obj_strings, closest_redshift_lcs):
 
                     try:
@@ -602,35 +611,49 @@ <h1 class="title">Module <code>deeplenstronomy.input_reader</code></h1>
 
         Args:
             configuration (str): like &#39;CONFIGURATION_1&#39;, &#39;CONFIGURATION_2&#39;, etc...
-            nites (List[int]): a list of nites relative to explosion to get a photometric measurement  
+            nites (List[int] or str): a list of nites relative to explosion to get a photometric measurement or the name of a cadence file  
             objects (List[str]):  a list of object names   
             redshift_dicts (List[dict]): a list of redshift information about the objects
             cosmo (astropy.cosmology): An astropy.cosmology instance for distance calculations
         &#34;&#34;&#34;
 
+        # Convert nites to a cadence dict
+        if isinstance(nites, str):
+            cadence_dict = read_cadence_file(nites)
+        else:
+            cadence_dict = {&#39;REFERENCE_MJD&#39;: 0.0,
+                            &#39;POINTING_1&#39;: {b: nites for b in self.main_dict[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;].split(&#39;,&#39;)}}
+        self.cadence_dict = cadence_dict
+
+        # Use the reference MJD to shift all the nites to be relative to 0
+        shifted_cadence_dict = {k: {b: [x - cadence_dict[&#39;REFERENCE_MJD&#39;] for x in cadence_dict[k][b]] for b in self.main_dict[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;].split(&#39;,&#39;)} for k in cadence_dict.keys() if k.startswith(&#39;POINTING_&#39;)}
+            
         # instantiate an LCGen object
         lc_gen = timeseries.LCGen(bands=self.main_dict[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;])
 
-        for obj, redshift_dict in zip(objects, redshift_dicts):
-            lc_library = []
-
-            # get redshifts to simulate light curves at
-            if isinstance(redshift_dict, dict):
-                drawn_redshifts = [self._draw(redshift_dict[&#39;DISTRIBUTION&#39;], bands=&#39;g&#39;) for _ in range(100)]
-                redshifts = np.linspace(np.min(drawn_redshifts), np.max(drawn_redshifts), 15)
-            else:
-                redshifts = np.array([redshift_dict])
+        # make a library for each pointing - need to speed this up (horrible performance for non-fixed redshifts and many pointings)
+        for pointing, nite_dict in shifted_cadence_dict.items():
+            
+            for obj, redshift_dict in zip(objects, redshift_dicts):
+                lc_library = []
+                
+                # get redshifts to simulate light curves at
+                if isinstance(redshift_dict, dict):
+                    drawn_redshifts = [self._draw(redshift_dict[&#39;DISTRIBUTION&#39;], bands=&#39;g&#39;) for _ in range(100)]
+                    redshifts = np.linspace(np.min(drawn_redshifts), np.max(drawn_redshifts), 15)
+                else:
+                    redshifts = np.array([redshift_dict])
 
-            # get model to simulate
-            model_info = self.main_dict[&#39;SPECIES&#39;][self._species_map[obj]][&#39;MODEL&#39;].split(&#39;_&#39;)
-            if model_info[-1].lower() == &#39;random&#39; or len(model_info) == 1:
-                for redshift in redshifts:
-                    lc_library.append(eval(&#39;lc_gen.gen_{0}(redshift, nites, cosmo=cosmo)&#39;.format(model_info[0])))
-            else:
-                for redshift in redshifts:
-                    lc_library.append(eval(&#39;lc_gen.gen_{0}(redshift, nites, sed_filename=&#34;{1}&#34;, cosmo=cosmo)&#39;.format(model_info[0], model_info[1])))
+                # get model to simulate
+                model_info = self.main_dict[&#39;SPECIES&#39;][self._species_map[obj]][&#39;MODEL&#39;].split(&#39;_&#39;)
+                if model_info[-1].lower() == &#39;random&#39; or len(model_info) == 1:
+                    for redshift in redshifts:
+                        lc_library.append(eval(&#39;lc_gen.gen_{0}(redshift, nite_dict, cosmo=cosmo)&#39;.format(model_info[0])))
+                else:
+                    for redshift in redshifts:
+                        lc_library.append(eval(&#39;lc_gen.gen_{0}(redshift, nite_dict, sed_filename=&#34;{1}&#34;, cosmo=cosmo)&#39;.format(model_info[0], model_info[1])))
             
-            setattr(self, configuration + &#39;_&#39; + obj + &#39;_&#39; + &#39;lightcurves&#39;, {&#39;library&#39;: lc_library, &#39;redshifts&#39;: redshifts})
+                setattr(self, configuration + &#39;_&#39; + obj + &#39;_lightcurves_&#39; + pointing, {&#39;library&#39;: lc_library, &#39;redshifts&#39;: redshifts})
         
         return
     
@@ -918,6 +941,11 @@ <h2 id="args">Args</h2>
         #Object IDs
         for band in bands:
             output_dict[band][&#39;OBJID&#39;] = objid
+
+        #Pointing
+        pointing = random.choice(list(set(self.cadence_dict.keys()) - set([&#39;REFERENCE_MJD&#39;])))
+        for band in bands:
+            output_dict[band][&#39;POINTING&#39;] = pointing
         
         #COSMOLOGY
         for k, v in config_dict[&#39;COSMOLOGY_DICT&#39;].items():
@@ -1152,18 +1180,22 @@ <h2 id="args">Args</h2>
         # Get flattened and filled dictionary
         base_output_dict = self._flatten_and_fill(config_dict, cosmo, objid)
 
+        pointing = base_output_dict[bands[0]][&#39;POINTING&#39;]
         closest_redshift_lcs = []
         for obj_name, obj_string in zip(self.main_dict[&#39;GEOMETRY&#39;][configuration][&#39;TIMESERIES&#39;][&#39;OBJECTS&#39;], obj_strings):
             # determine closest lc in library to redshift
             redshift = base_output_dict[bands[0]][obj_string + &#39;-REDSHIFT&#39;]
-            lcs = eval(&#39;self.{0}_{1}_lightcurves&#39;.format(configuration, obj_name))
+            lcs = eval(&#39;self.{0}_{1}_lightcurves_{2}&#39;.format(configuration, obj_name, pointing))
             closest_redshift_lcs.append(lcs[&#39;library&#39;][np.argmin(np.abs(redshift - lcs[&#39;redshifts&#39;]))])
             
-        # overwrite the image sim dictionary        
-        for orig_nite in self.main_dict[&#39;GEOMETRY&#39;][configuration][&#39;TIMESERIES&#39;][&#39;NITES&#39;]:
-            nite = orig_nite - peakshift
-            output_dict = base_output_dict.copy()
+        # overwrite the image sim dictionary
+        nite_dict = self.cadence_dict[pointing]
+        for nite_idx in range(len(nite_dict[bands[0]])):
             for band in bands:
+                orig_nite = nite_dict[band][nite_idx]
+                #for orig_nite in nite_dict[band]:
+                nite = orig_nite - peakshift
+                output_dict = base_output_dict.copy()
                 for obj_sting, closest_redshift_lc in zip(obj_strings, closest_redshift_lcs):
 
                     try:
@@ -1204,35 +1236,49 @@ <h2 id="args">Args</h2>
 
         Args:
             configuration (str): like &#39;CONFIGURATION_1&#39;, &#39;CONFIGURATION_2&#39;, etc...
-            nites (List[int]): a list of nites relative to explosion to get a photometric measurement  
+            nites (List[int] or str): a list of nites relative to explosion to get a photometric measurement or the name of a cadence file  
             objects (List[str]):  a list of object names   
             redshift_dicts (List[dict]): a list of redshift information about the objects
             cosmo (astropy.cosmology): An astropy.cosmology instance for distance calculations
         &#34;&#34;&#34;
 
+        # Convert nites to a cadence dict
+        if isinstance(nites, str):
+            cadence_dict = read_cadence_file(nites)
+        else:
+            cadence_dict = {&#39;REFERENCE_MJD&#39;: 0.0,
+                            &#39;POINTING_1&#39;: {b: nites for b in self.main_dict[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;].split(&#39;,&#39;)}}
+        self.cadence_dict = cadence_dict
+
+        # Use the reference MJD to shift all the nites to be relative to 0
+        shifted_cadence_dict = {k: {b: [x - cadence_dict[&#39;REFERENCE_MJD&#39;] for x in cadence_dict[k][b]] for b in self.main_dict[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;].split(&#39;,&#39;)} for k in cadence_dict.keys() if k.startswith(&#39;POINTING_&#39;)}
+            
         # instantiate an LCGen object
         lc_gen = timeseries.LCGen(bands=self.main_dict[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;])
 
-        for obj, redshift_dict in zip(objects, redshift_dicts):
-            lc_library = []
-
-            # get redshifts to simulate light curves at
-            if isinstance(redshift_dict, dict):
-                drawn_redshifts = [self._draw(redshift_dict[&#39;DISTRIBUTION&#39;], bands=&#39;g&#39;) for _ in range(100)]
-                redshifts = np.linspace(np.min(drawn_redshifts), np.max(drawn_redshifts), 15)
-            else:
-                redshifts = np.array([redshift_dict])
+        # make a library for each pointing - need to speed this up (horrible performance for non-fixed redshifts and many pointings)
+        for pointing, nite_dict in shifted_cadence_dict.items():
+            
+            for obj, redshift_dict in zip(objects, redshift_dicts):
+                lc_library = []
+                
+                # get redshifts to simulate light curves at
+                if isinstance(redshift_dict, dict):
+                    drawn_redshifts = [self._draw(redshift_dict[&#39;DISTRIBUTION&#39;], bands=&#39;g&#39;) for _ in range(100)]
+                    redshifts = np.linspace(np.min(drawn_redshifts), np.max(drawn_redshifts), 15)
+                else:
+                    redshifts = np.array([redshift_dict])
 
-            # get model to simulate
-            model_info = self.main_dict[&#39;SPECIES&#39;][self._species_map[obj]][&#39;MODEL&#39;].split(&#39;_&#39;)
-            if model_info[-1].lower() == &#39;random&#39; or len(model_info) == 1:
-                for redshift in redshifts:
-                    lc_library.append(eval(&#39;lc_gen.gen_{0}(redshift, nites, cosmo=cosmo)&#39;.format(model_info[0])))
-            else:
-                for redshift in redshifts:
-                    lc_library.append(eval(&#39;lc_gen.gen_{0}(redshift, nites, sed_filename=&#34;{1}&#34;, cosmo=cosmo)&#39;.format(model_info[0], model_info[1])))
+                # get model to simulate
+                model_info = self.main_dict[&#39;SPECIES&#39;][self._species_map[obj]][&#39;MODEL&#39;].split(&#39;_&#39;)
+                if model_info[-1].lower() == &#39;random&#39; or len(model_info) == 1:
+                    for redshift in redshifts:
+                        lc_library.append(eval(&#39;lc_gen.gen_{0}(redshift, nite_dict, cosmo=cosmo)&#39;.format(model_info[0])))
+                else:
+                    for redshift in redshifts:
+                        lc_library.append(eval(&#39;lc_gen.gen_{0}(redshift, nite_dict, sed_filename=&#34;{1}&#34;, cosmo=cosmo)&#39;.format(model_info[0], model_info[1])))
             
-            setattr(self, configuration + &#39;_&#39; + obj + &#39;_&#39; + &#39;lightcurves&#39;, {&#39;library&#39;: lc_library, &#39;redshifts&#39;: redshifts})
+                setattr(self, configuration + &#39;_&#39; + obj + &#39;_lightcurves_&#39; + pointing, {&#39;library&#39;: lc_library, &#39;redshifts&#39;: redshifts})
         
         return
     
@@ -1548,8 +1594,8 @@ <h2 id="args">Args</h2>
 <dl>
 <dt><strong><code>configuration</code></strong> :&ensp;<code>str</code></dt>
 <dd>like 'CONFIGURATION_1', 'CONFIGURATION_2', etc&hellip;</dd>
-<dt><strong><code>nites</code></strong> :&ensp;<code>List[int]</code></dt>
-<dd>a list of nites relative to explosion to get a photometric measurement
+<dt><strong><code>nites</code></strong> :&ensp;<code>List[int]</code> or <code>str</code></dt>
+<dd>a list of nites relative to explosion to get a photometric measurement or the name of a cadence file
 </dd>
 <dt><strong><code>objects</code></strong> :&ensp;<code>List[str]</code></dt>
 <dd>a list of object names
@@ -1569,35 +1615,49 @@ <h2 id="args">Args</h2>
 
     Args:
         configuration (str): like &#39;CONFIGURATION_1&#39;, &#39;CONFIGURATION_2&#39;, etc...
-        nites (List[int]): a list of nites relative to explosion to get a photometric measurement  
+        nites (List[int] or str): a list of nites relative to explosion to get a photometric measurement or the name of a cadence file  
         objects (List[str]):  a list of object names   
         redshift_dicts (List[dict]): a list of redshift information about the objects
         cosmo (astropy.cosmology): An astropy.cosmology instance for distance calculations
     &#34;&#34;&#34;
 
+    # Convert nites to a cadence dict
+    if isinstance(nites, str):
+        cadence_dict = read_cadence_file(nites)
+    else:
+        cadence_dict = {&#39;REFERENCE_MJD&#39;: 0.0,
+                        &#39;POINTING_1&#39;: {b: nites for b in self.main_dict[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;].split(&#39;,&#39;)}}
+    self.cadence_dict = cadence_dict
+
+    # Use the reference MJD to shift all the nites to be relative to 0
+    shifted_cadence_dict = {k: {b: [x - cadence_dict[&#39;REFERENCE_MJD&#39;] for x in cadence_dict[k][b]] for b in self.main_dict[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;].split(&#39;,&#39;)} for k in cadence_dict.keys() if k.startswith(&#39;POINTING_&#39;)}
+        
     # instantiate an LCGen object
     lc_gen = timeseries.LCGen(bands=self.main_dict[&#39;SURVEY&#39;][&#39;PARAMETERS&#39;][&#39;BANDS&#39;])
 
-    for obj, redshift_dict in zip(objects, redshift_dicts):
-        lc_library = []
-
-        # get redshifts to simulate light curves at
-        if isinstance(redshift_dict, dict):
-            drawn_redshifts = [self._draw(redshift_dict[&#39;DISTRIBUTION&#39;], bands=&#39;g&#39;) for _ in range(100)]
-            redshifts = np.linspace(np.min(drawn_redshifts), np.max(drawn_redshifts), 15)
-        else:
-            redshifts = np.array([redshift_dict])
+    # make a library for each pointing - need to speed this up (horrible performance for non-fixed redshifts and many pointings)
+    for pointing, nite_dict in shifted_cadence_dict.items():
+        
+        for obj, redshift_dict in zip(objects, redshift_dicts):
+            lc_library = []
+            
+            # get redshifts to simulate light curves at
+            if isinstance(redshift_dict, dict):
+                drawn_redshifts = [self._draw(redshift_dict[&#39;DISTRIBUTION&#39;], bands=&#39;g&#39;) for _ in range(100)]
+                redshifts = np.linspace(np.min(drawn_redshifts), np.max(drawn_redshifts), 15)
+            else:
+                redshifts = np.array([redshift_dict])
 
-        # get model to simulate
-        model_info = self.main_dict[&#39;SPECIES&#39;][self._species_map[obj]][&#39;MODEL&#39;].split(&#39;_&#39;)
-        if model_info[-1].lower() == &#39;random&#39; or len(model_info) == 1:
-            for redshift in redshifts:
-                lc_library.append(eval(&#39;lc_gen.gen_{0}(redshift, nites, cosmo=cosmo)&#39;.format(model_info[0])))
-        else:
-            for redshift in redshifts:
-                lc_library.append(eval(&#39;lc_gen.gen_{0}(redshift, nites, sed_filename=&#34;{1}&#34;, cosmo=cosmo)&#39;.format(model_info[0], model_info[1])))
+            # get model to simulate
+            model_info = self.main_dict[&#39;SPECIES&#39;][self._species_map[obj]][&#39;MODEL&#39;].split(&#39;_&#39;)
+            if model_info[-1].lower() == &#39;random&#39; or len(model_info) == 1:
+                for redshift in redshifts:
+                    lc_library.append(eval(&#39;lc_gen.gen_{0}(redshift, nite_dict, cosmo=cosmo)&#39;.format(model_info[0])))
+            else:
+                for redshift in redshifts:
+                    lc_library.append(eval(&#39;lc_gen.gen_{0}(redshift, nite_dict, sed_filename=&#34;{1}&#34;, cosmo=cosmo)&#39;.format(model_info[0], model_info[1])))
         
-        setattr(self, configuration + &#39;_&#39; + obj + &#39;_&#39; + &#39;lightcurves&#39;, {&#39;library&#39;: lc_library, &#39;redshifts&#39;: redshifts})
+            setattr(self, configuration + &#39;_&#39; + obj + &#39;_lightcurves_&#39; + pointing, {&#39;library&#39;: lc_library, &#39;redshifts&#39;: redshifts})
     
     return</code></pre>
 </details>
diff --git a/docs/timeseries.html b/docs/timeseries.html
index 1a1bebd..2a5f66e 100644
--- a/docs/timeseries.html
+++ b/docs/timeseries.html
@@ -65,10 +65,21 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         self.bands = bands.split(&#39;,&#39;)
         
         # Interpolate the transmission curves
+        self.norm_dict = {}
         for band in self.bands:
             transmission_frequency, transmission_wavelength = self.__read_passband(band)
             setattr(self, &#39;{0}_transmission_frequency&#39;.format(band), transmission_frequency)
             setattr(self, &#39;{0}_transmission_wavelength&#39;.format(band), transmission_wavelength)
+            
+            # Store normalizations
+            lower_bound = eval(&#39;self._{0}_obs_frame_freq_min&#39;.format(band))
+            upper_bound = eval(&#39;self._{0}_obs_frame_freq_max&#39;.format(band))        
+            frequency_arr = np.linspace(upper_bound, lower_bound, 10000)
+            norm_arr = np.ones(len(frequency_arr)) * 3631.0
+            
+            norm_sed = pd.DataFrame(data=np.vstack((norm_arr, frequency_arr)).T,
+                                    columns=[&#39;FLUX&#39;, &#39;FREQUENCY_REST&#39;])
+            self.norm_dict[band] = self._integrate_through_band(norm_sed, band, 0.0, frame=&#39;REST&#39;)
         
         return
 
@@ -122,8 +133,8 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         setattr(self, &#39;_{0}_obs_frame_freq_max&#39;.format(band), 2.99792458e18 / np.min(passband[&#39;WAVELENGTH&#39;].values))
         
         # Add boundary terms to cover the whole range
-        passband.loc[passband.shape[0]] = (1.e-1, 0.0)
-        passband.loc[passband.shape[0]] = (4.e+4, 0.0)
+        passband.loc[passband.shape[0]] = (1.e-9, 0.0)
+        passband.loc[passband.shape[0]] = (4.e+9, 0.0)
         
         # Convert to frequency using speed of light in angstroms
         passband[&#39;FREQUENCY&#39;] = 2.99792458e18 / passband[&#39;WAVELENGTH&#39;].values
@@ -147,17 +158,26 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         sed = pd.read_csv(sed_filename,
                           names=[&#39;NITE&#39;, &#39;WAVELENGTH_REST&#39;, &#39;FLUX&#39;], 
                           delim_whitespace=True, comment=&#39;#&#39;)
+
+        # Remove unrealistic wavelengths
+        sed = sed[sed[&#39;WAVELENGTH_REST&#39;].values &gt; 10.0].copy().reset_index(drop=True)
+        
+        # Add new boundaries
+        boundary_data = []
         for nite in np.unique(sed[&#39;NITE&#39;].values):
-            sed.loc[sed.shape[0]] = (nite, 10.0, 0.0)
-            sed.loc[sed.shape[0]] = (nite, 25000.0, 0.0)
+            boundary_data.append((nite, 10.0, 0.0))
+            boundary_data.append((nite, 25000.0, 0.0))
+        sed = sed.append(pd.DataFrame(data=boundary_data, columns=[&#39;NITE&#39;, &#39;WAVELENGTH_REST&#39;, &#39;FLUX&#39;]))
+
+        # Convert to frequency
         sed[&#39;FREQUENCY_REST&#39;] = 2.99792458e18 / sed[&#39;WAVELENGTH_REST&#39;].values
-        
+
         # Normalize
         func = interp1d(sed[&#39;WAVELENGTH_REST&#39;].values, sed[&#39;FLUX&#39;].values)
         sed[&#39;FLUX&#39;] = sed[&#39;FLUX&#39;].values / quad(func, 10.0, 25000.0)[0]
         
         # Round nights to nearest int
-        sed[&#39;NITE&#39;] = [round(x) for x in sed[&#39;NITE&#39;].values]
+        sed[&#39;NITE&#39;] = sed[&#39;NITE&#39;].values.round()
         
         return sed
     
@@ -173,6 +193,20 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         return -2.5 * np.log10((1.0 + redshift) * 
                                (self._integrate_through_band(sed, band, redshift, frame=&#39;OBS&#39;) /
                                 self._integrate_through_band(sed, band, redshift, frame=&#39;REST&#39;)))
+    
+    def _get_kcorrections(self, sed, sed_filename, redshift):
+        &#34;&#34;&#34;
+        Cache the k-correction factors and return
+        &#34;&#34;&#34;
+        attr_name = sed_filename.split(&#39;.&#39;)[0] + &#39;-kcorrect_dict-&#39; + str(redshift*100).split(&#39;.&#39;)[0]
+        if hasattr(self, attr_name):
+            return [getattr(self, attr_name)[b] for b in self.bands]
+        else:
+            peak_sed = sed[sed[&#39;NITE&#39;].values == self._get_closest_nite(np.unique(sed[&#39;NITE&#39;].values), 0)].copy().reset_index(drop=True)
+            k_corrections = [self._get_kcorrect(peak_sed, band, redshift) for band in self.bands]
+            setattr(self, attr_name, {b: k for b, k in zip(self.bands, k_corrections)})
+            return k_corrections
+        
         
     def _get_distance_modulus(self, redshift, cosmo):
         &#34;&#34;&#34;
@@ -194,19 +228,12 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         :param redshift: the redshift of the source
         :param frame: chose from [&#39;REST&#39;, &#39;OBS&#39;] to choose the rest frame or the observer frame
         :return: flux: the measured flux from the source through the filter
-        &#34;&#34;&#34;
-        # Tighten bounds for accurate integration
-        lower_bound = eval(&#39;self._{0}_obs_frame_freq_min&#39;.format(band))
-        upper_bound = eval(&#39;self._{0}_obs_frame_freq_max&#39;.format(band))        
-        frequency_arr = np.linspace(lower_bound, upper_bound, 100000)
-        
-        # Make an interpolated version of the integrand
-        interpolated_sed = interp1d(sed[&#39;FREQUENCY_{0}&#39;.format(frame)].values, sed[&#39;FLUX&#39;].values, fill_value=0.0)
-        integrand = eval(&#39;self.{0}_transmission_frequency(frequency_arr) * interpolated_sed(frequency_arr) / frequency_arr&#39;.format(band))
-        interpolated_integrand = interp1d(frequency_arr, integrand, fill_value=0.0)
-               
-        # Integrate and return
-        return quad(interpolated_integrand, lower_bound, upper_bound, limit=500)[0]
+        &#34;&#34;&#34;     
+        frequency_arr = sed[&#39;FREQUENCY_{0}&#39;.format(frame)].values
+        delta_frequencies = np.diff(frequency_arr) * -1.0
+        integrand = eval(&#34;self.{0}_transmission_frequency(frequency_arr) * sed[&#39;FLUX&#39;].values / frequency_arr&#34;.format(band))
+        average_integrands = 0.5 * np.diff(integrand) + integrand[0:-1]
+        return np.sum(delta_frequencies * average_integrands)
     
     def _get_closest_nite(self, unique_nites, nite):
         &#34;&#34;&#34;
@@ -216,15 +243,21 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         :param nite: the nite you wish to find the closest neighbor for
         :return: closest_nite: the closest nite in the sed to the given nite
         &#34;&#34;&#34;
-        return unique_nites[np.argmin(np.abs(nite - unique_nites))]
+        
+        ## If nite not in the sed, (but within range) set nite to the closest nite in the sed
+        ## If nite is outside range, keep the same
+        if nite &gt; unique_nites.max() or nite &lt; unique_nites.min():
+            return nite
+        else:
+            return unique_nites[np.argmin(np.abs(nite - unique_nites))]
 
-    def gen_variable(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_variable(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a random variable light curve
 
         Args:
             redshift (float): ignored 
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for    
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey    
             sed_filename (str): ignored
             cosmo (astropy.cosmology): ignored
 
@@ -238,22 +271,22 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         output_data = []
         central_mag = random.uniform(12.0, 23.0)
         colors = {band: mag for band, mag in zip(self.bands, np.random.uniform(low=-2.0, high=2.0, size=len(self.bands)))}
-        for nite in nites:
-            central_mag = random.uniform(central_mag - 1.0, central_mag + 1.0)
-            for band in self.bands:
+        for band in self.bands:
+            for nite in nite_dict[band]:
+                central_mag = random.uniform(central_mag - 1.0, central_mag + 1.0)
                 output_data.append([nite, band, central_mag + colors[band]])
 
         return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols),
                 &#39;obj_type&#39;: &#39;Variable&#39;,
                 &#39;sed&#39;: &#39;Variable&#39;}
     
-    def gen_flat(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_flat(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a random flat light curve.
         
         Args:
             redshift (float): ignored
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey
             sed_filename (str): ignored
             cosmo (astropy.cosmology): ignored
 
@@ -267,35 +300,36 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         central_mag = random.uniform(12.0, 23.0)
         mags = {band: mag for band, mag in zip(self.bands, central_mag + np.random.uniform(low=-2.0, high=2.0, size=len(self.bands)))}
         output_data = []
-        for nite in nites:
-            for band in self.bands:
+        for band in self.bands:
+            for nite in nite_dict[band]:
                 output_data.append([nite, band, mags[band]])
 
         return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols),
                 &#39;obj_type&#39;: &#39;Flat&#39;,
                 &#39;sed&#39;: &#39;Flat&#39;}
 
-    def gen_static(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_static(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Make a static source capable of having time-series data by introducing a mag=99 source
         on each NITE of the simulation.
 
         Args:
             redshift (float): ignored 
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey
             sed_filename (str): ignored                                                                                                                                                               
             cosmo (astropy.cosmology): ignored                                                                                                                                                                                            
         Returns:
             lc_dict: a dictionary with keys [&#39;lc, &#39;obj_type&#39;, &#39;sed&#39;]
               - &#39;lc&#39; contains a dataframe of the light from the object
               - &#39;obj_type&#39; contains a string for the type of object. Will always be &#39;Static&#39; here
-              - &#39;sed&#39; contains the filename of the sed used. Will always be &#39;Flat&#39; here                                                                                                                        &#34;&#34;&#34;
+              - &#39;sed&#39; contains the filename of the sed used. Will always be &#39;Flat&#39; here     
+        &#34;&#34;&#34;
         output_data_cols = [&#39;NITE&#39;, &#39;BAND&#39;, &#39;MAG&#39;]
         central_mag = 99.0
         mags = {band: central_mag for band in self.bands}
         output_data = []
-        for nite in nites:
-            for band in self.bands:
+        for band in self.bands:
+            for nite in nite_dict[band]:
                 output_data.append([nite, band, mags[band]])
 
         return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols),
@@ -304,13 +338,13 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
 
 
         
-    def gen_variablenoise(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_variablenoise(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34; 
         Generate a variable light curve with small random noise
 
         Args:
             redshift (float): ignored
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey
             sed_filename (str): ignored
             cosmo (astropy.cosmology): ignored
 
@@ -320,7 +354,7 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
               - &#39;obj_type&#39; contains a string for the type of object. Will always be &#39;VariableNoise&#39; here
               - &#39;sed&#39; contains the filename of the sed used. Will always be &#39;VariableNoise&#39; here              
         &#34;&#34;&#34;
-        noiseless_lc_dict = self.gen_variable(redshift, nites)
+        noiseless_lc_dict = self.gen_variable(redshift, nite_dict)
         noise = np.random.normal(loc=0, scale=0.25, size=noiseless_lc_dict[&#39;lc&#39;].shape[0])
         noiseless_lc_dict[&#39;lc&#39;][&#39;MAG&#39;] = noiseless_lc_dict[&#39;lc&#39;][&#39;MAG&#39;].values + noise
         noiseless_lc_dict[&#39;obj_type&#39;] = &#39;VariableNoise&#39;
@@ -328,13 +362,13 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         return noiseless_lc_dict
 
     
-    def gen_flatnoise(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_flatnoise(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a flat light curve will small random noise
 
         Args:
             redshift (float): ignored
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey
             sed_filename (str): ignored
             cosmo (astropy.cosmology): ignored
 
@@ -344,20 +378,20 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
               - &#39;obj_type&#39; contains a string for the type of object. Will always be &#39;FlatNoise&#39; here
               - &#39;sed&#39; contains the filename of the sed used. Will always be &#39;FlatNoise&#39; here              
         &#34;&#34;&#34;
-        noiseless_lc_dict = self.gen_flat(redshift, nites)
+        noiseless_lc_dict = self.gen_flat(redshift, nite_dict)
         noise = np.random.normal(loc=0, scale=0.25, size=noiseless_lc_dict[&#39;lc&#39;].shape[0])
         noiseless_lc_dict[&#39;lc&#39;][&#39;MAG&#39;] = noiseless_lc_dict[&#39;lc&#39;][&#39;MAG&#39;].values + noise
         noiseless_lc_dict[&#39;obj_type&#39;] = &#39;FlatNoise&#39;
         noiseless_lc_dict[&#39;sed&#39;] = &#39;FlatNoise&#39;
         return noiseless_lc_dict
         
-    def gen_user(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_user(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a light curve from a user-specidied SED
 
         Args:
             redshift (float): the redshift of the source
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
             sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
             sed_filename (str): filename containing the time-series sed you want to use 
             cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -368,18 +402,28 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
               - &#39;obj_type&#39; contains a string for the type of object. Will always be &lt;sed_filename&gt; here 
               - &#39;sed&#39; contains the filename of the sed used  
         &#34;&#34;&#34;
-        if not sed:
-            sed = self._read_sed(&#39;seds/user/&#39; + sed_filename)
+        if sed is None:
+            if sed_filename.startswith(&#39;seds/user/&#39;):
+                attr_name = sed_filename.split(&#39;.&#39;)[0]
+            else:
+                attr_name = &#39;seds/user/&#39; + sed_filename.split(&#39;.&#39;)[0]
+                sed_filename = &#39;seds/user/&#39; + sed_filename
+                
+            if hasattr(self, attr_name):
+                sed = getattr(self, attr_name)
+            else:
+                sed = self._read_sed(sed_filename)
+                setattr(self, attr_name, sed)
 
-        return self.gen_lc_from_sed(redshift, nites, sed, sed_filename, sed_filename, cosmo=cosmo)
+        return self.gen_lc_from_sed(redshift, nite_dict, sed, sed_filename, sed_filename, cosmo=cosmo)
 
-    def gen_kn(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_kn(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a GW170817-like light curve.
 
         Args:
             redshift (float): the redshift of the source
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
             sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
             sed_filename (str): filename containing the time-series sed you want to use 
             cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -392,19 +436,23 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         &#34;&#34;&#34;
 
         sed_filename = &#39;seds/kn/kn.SED&#39;
-        if not sed:
-            sed = self._read_sed(sed_filename)
-
-        return self.gen_lc_from_sed(redshift, nites, sed, &#39;KN&#39;, sed_filename, cosmo=cosmo)
+        if sed is None:
+            attr_name = sed_filename.split(&#39;.&#39;)[0]
+            if hasattr(self, attr_name):
+                sed = getattr(self, attr_name)
+            else:
+                sed = self._read_sed(sed_filename)
+                setattr(self, attr_name, sed)
+                
+        return self.gen_lc_from_sed(redshift, nite_dict, sed, &#39;KN&#39;, sed_filename, cosmo=cosmo)
     
-    def gen_ia(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_ia(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a SN-Ia light curve.
-        
 
         Args:
             redshift (float): the redshift of the source
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
             sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
             sed_filename (str): filename containing the time-series sed you want to use 
             cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -417,23 +465,32 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         &#34;&#34;&#34;
         
         # Read rest-frame sed if not supplied as argument
-        if not sed:
-            if sed_filename:
-                sed = self._read_sed(&#39;seds/ia/&#39; + sed_filename)
-            else:
+        if sed is None:
+            if sed_filename is None:
                 sed_filename = random.choice(self.ia_sed_files)
+            
+            if sed_filename.startswith(&#39;seds/ia/&#39;):
+                attr_name = sed_filename.split(&#39;.&#39;)[0]
+            else:
+                attr_name = &#39;seds/ia/&#39; + sed_filename.split(&#39;.&#39;)[0]
+                sed_filename = &#39;seds/ia/&#39; + sed_filename
+
+            if hasattr(self, attr_name):
+                sed = getattr(self, attr_name)
+            else:
                 sed = self._read_sed(sed_filename)
+                setattr(self, attr_name, sed)
                 
         # Trigger the lc generation function on this sed
-        return self.gen_lc_from_sed(redshift, nites, sed, &#39;Ia&#39;, sed_filename, cosmo=cosmo)
+        return self.gen_lc_from_sed(redshift, nite_dict, sed, &#39;Ia&#39;, sed_filename, cosmo=cosmo)
     
-    def gen_cc(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_cc(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a SN-CC light curve
         
         Args:
             redshift (float): the redshift of the source
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
             sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
             sed_filename (str): filename containing the time-series sed you want to use 
             cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -446,26 +503,35 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         &#34;&#34;&#34;
 
         # If sed not specified, choose sed based on weight map
-        if not sed:
-            if sed_filename:
-                sed = self._read_sed(&#39;seds/cc/&#39; + sed_filename)
-            else:
+        if sed is None:
+            if sed_filename is None:
                 sed_filename = random.choices(self.cc_sed_files, weights=self.cc_weights, k=1)[0]
+
+            if sed_filename.startswith(&#39;seds/cc/&#39;):
+                attr_name = sed_filename.split(&#39;.&#39;)[0]
+            else:
+                attr_name = &#39;seds/cc/&#39; + sed_filename.split(&#39;.&#39;)[0]
+                sed_filename = &#39;seds/cc/&#39; + sed_filename
+                    
+            if hasattr(self, attr_name):
+                sed = getattr(self, attr_name)
+            else:
                 sed = self._read_sed(sed_filename)
+                setattr(self, attr_name, sed)
         
         # Get the type of SN-CC
         obj_type = self.cc_info_df[&#39;SNTYPE&#39;].values[self.cc_info_df[&#39;SED&#39;].values == sed_filename.split(&#39;/&#39;)[-1].split(&#39;.&#39;)[0]][0]
         
         # Trigger the lc generation function on this sed
-        return self.gen_lc_from_sed(redshift, nites, sed, obj_type, sed_filename, cosmo=cosmo)
+        return self.gen_lc_from_sed(redshift, nite_dict, sed, obj_type, sed_filename, cosmo=cosmo)
                 
-    def gen_lc_from_sed(self, redshift, nites, sed, obj_type, sed_filename, cosmo=None):
+    def gen_lc_from_sed(self, redshift, nite_dict, sed, obj_type, sed_filename, cosmo=None):
         &#34;&#34;&#34;
         Generate a light curve based on a time-series sed.
         
         Args:
             redshift (float): the redshift of the source
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
             sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
             sed_filename (str): filename containing the time-series sed you want to use 
             cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -477,15 +543,17 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
               - &#39;sed&#39; contains the filename of the sed used  
         &#34;&#34;&#34;
         
-        # If nite not in the sed, set nite to the closest nite in the sed
-        useable_nites = []
+        # Adjust nites
+        nites = {}
         sed_nites = np.unique(sed[&#39;NITE&#39;].values)
-        for nite in nites:
-            if nite not in sed_nites:
-                useable_nites.append(self._get_closest_nite(sed_nites, nite))
-            else:
-                useable_nites.append(nite)
-        nites = useable_nites
+        for band, cad_nites in nite_dict.items():
+            useable_nites = []
+            for nite in cad_nites:
+                if nite not in sed_nites:
+                    useable_nites.append(self._get_closest_nite(sed_nites, nite))
+                else:
+                    useable_nites.append(nite)
+            nites[band] = useable_nites
             
         # Redshift the sed frequencies and wavelengths
         sed[&#39;WAVELENGTH_OBS&#39;] = (1.0 + redshift) * sed[&#39;WAVELENGTH_REST&#39;].values
@@ -498,35 +566,33 @@ <h1 class="title">Module <code>deeplenstronomy.timeseries</code></h1>
         distance_modulus = self._get_distance_modulus(redshift, cosmo=cosmo)
         
         # Calculate k-correction at peak
-        peak_sed = sed[sed[&#39;NITE&#39;].values == self._get_closest_nite(np.unique(sed[&#39;NITE&#39;].values), 0)].copy().reset_index(drop=True)
-        k_corrections = [self._get_kcorrect(peak_sed, band, redshift) for band in self.bands]
+        k_corrections = self._get_kcorrections(sed, sed_filename, redshift)
         
         # On each nite, in each band, calculate the absolute mag
         output_data = []
         output_data_cols = [&#39;NITE&#39;, &#39;BAND&#39;, &#39;MAG&#39;]
-        for nite in nites:
-            nite_sed = sed[sed[&#39;NITE&#39;].values == nite].copy().reset_index(drop=True)
-            
-            # Apply factors to calculate absolute mag
-            nite_sed[&#39;FLUX&#39;] = (cosmo.luminosity_distance(redshift).value * 10 ** 6 / 10) ** 2 / (1 + redshift) * nite_sed[&#39;FLUX&#39;].values
-            nite_sed[&#39;FREQUENCY_REST&#39;] = nite_sed[&#39;FREQUENCY_REST&#39;].values / (1. + redshift)
-            
-            # Convert to AB Magnitude system
-            norm_sed = nite_sed.copy()
-            norm_sed[&#39;FLUX&#39;] = 3631.0
+        
+        for band, k_correction in zip(self.bands, k_corrections):
             
-            for band, k_correction in zip(self.bands, k_corrections):
+            for nite in nites[band]:
+                nite_sed = sed[sed[&#39;NITE&#39;].values == nite].copy().reset_index(drop=True)
+                
+                # Flux is zero if requested nite is noe in sed
+                if len(nite_sed) == 0:
+                    output_data.append([nite, band, 99.0])
+                    continue
                 
+                # Apply factors to calculate absolute mag
+                nite_sed[&#39;FLUX&#39;] = (cosmo.luminosity_distance(redshift).value * 10 ** 6 / 10) ** 2 / (1 + redshift) * nite_sed[&#39;FLUX&#39;].values
+                nite_sed[&#39;FREQUENCY_REST&#39;] = nite_sed[&#39;FREQUENCY_REST&#39;].values / (1. + redshift)
+            
                 # Calculate the apparent magnitude
-                norm = self._integrate_through_band(norm_sed, band, redshift, frame=&#39;REST&#39;)
-                absolute_ab_mag = self._integrate_through_band(nite_sed, band, redshift, frame=&#39;REST&#39;) / norm
+                absolute_ab_mag = self._integrate_through_band(nite_sed, band, redshift, frame=&#39;REST&#39;) / self.norm_dict[band]
                 output_data.append([nite, band, -2.5 * np.log10(absolute_ab_mag) + distance_modulus + k_correction])
                 
-        return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols).replace(np.nan, 30.0, inplace=False),
+        return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols).replace(np.nan, 99.0, inplace=False),
                 &#39;obj_type&#39;: obj_type,
-                &#39;sed&#39;: sed_filename}
-
-    </code></pre>
+                &#39;sed&#39;: sed_filename}</code></pre>
 </details>
 </section>
 <section>
@@ -578,10 +644,21 @@ <h2 id="args">Args</h2>
         self.bands = bands.split(&#39;,&#39;)
         
         # Interpolate the transmission curves
+        self.norm_dict = {}
         for band in self.bands:
             transmission_frequency, transmission_wavelength = self.__read_passband(band)
             setattr(self, &#39;{0}_transmission_frequency&#39;.format(band), transmission_frequency)
             setattr(self, &#39;{0}_transmission_wavelength&#39;.format(band), transmission_wavelength)
+            
+            # Store normalizations
+            lower_bound = eval(&#39;self._{0}_obs_frame_freq_min&#39;.format(band))
+            upper_bound = eval(&#39;self._{0}_obs_frame_freq_max&#39;.format(band))        
+            frequency_arr = np.linspace(upper_bound, lower_bound, 10000)
+            norm_arr = np.ones(len(frequency_arr)) * 3631.0
+            
+            norm_sed = pd.DataFrame(data=np.vstack((norm_arr, frequency_arr)).T,
+                                    columns=[&#39;FLUX&#39;, &#39;FREQUENCY_REST&#39;])
+            self.norm_dict[band] = self._integrate_through_band(norm_sed, band, 0.0, frame=&#39;REST&#39;)
         
         return
 
@@ -635,8 +712,8 @@ <h2 id="args">Args</h2>
         setattr(self, &#39;_{0}_obs_frame_freq_max&#39;.format(band), 2.99792458e18 / np.min(passband[&#39;WAVELENGTH&#39;].values))
         
         # Add boundary terms to cover the whole range
-        passband.loc[passband.shape[0]] = (1.e-1, 0.0)
-        passband.loc[passband.shape[0]] = (4.e+4, 0.0)
+        passband.loc[passband.shape[0]] = (1.e-9, 0.0)
+        passband.loc[passband.shape[0]] = (4.e+9, 0.0)
         
         # Convert to frequency using speed of light in angstroms
         passband[&#39;FREQUENCY&#39;] = 2.99792458e18 / passband[&#39;WAVELENGTH&#39;].values
@@ -660,17 +737,26 @@ <h2 id="args">Args</h2>
         sed = pd.read_csv(sed_filename,
                           names=[&#39;NITE&#39;, &#39;WAVELENGTH_REST&#39;, &#39;FLUX&#39;], 
                           delim_whitespace=True, comment=&#39;#&#39;)
+
+        # Remove unrealistic wavelengths
+        sed = sed[sed[&#39;WAVELENGTH_REST&#39;].values &gt; 10.0].copy().reset_index(drop=True)
+        
+        # Add new boundaries
+        boundary_data = []
         for nite in np.unique(sed[&#39;NITE&#39;].values):
-            sed.loc[sed.shape[0]] = (nite, 10.0, 0.0)
-            sed.loc[sed.shape[0]] = (nite, 25000.0, 0.0)
+            boundary_data.append((nite, 10.0, 0.0))
+            boundary_data.append((nite, 25000.0, 0.0))
+        sed = sed.append(pd.DataFrame(data=boundary_data, columns=[&#39;NITE&#39;, &#39;WAVELENGTH_REST&#39;, &#39;FLUX&#39;]))
+
+        # Convert to frequency
         sed[&#39;FREQUENCY_REST&#39;] = 2.99792458e18 / sed[&#39;WAVELENGTH_REST&#39;].values
-        
+
         # Normalize
         func = interp1d(sed[&#39;WAVELENGTH_REST&#39;].values, sed[&#39;FLUX&#39;].values)
         sed[&#39;FLUX&#39;] = sed[&#39;FLUX&#39;].values / quad(func, 10.0, 25000.0)[0]
         
         # Round nights to nearest int
-        sed[&#39;NITE&#39;] = [round(x) for x in sed[&#39;NITE&#39;].values]
+        sed[&#39;NITE&#39;] = sed[&#39;NITE&#39;].values.round()
         
         return sed
     
@@ -686,6 +772,20 @@ <h2 id="args">Args</h2>
         return -2.5 * np.log10((1.0 + redshift) * 
                                (self._integrate_through_band(sed, band, redshift, frame=&#39;OBS&#39;) /
                                 self._integrate_through_band(sed, band, redshift, frame=&#39;REST&#39;)))
+    
+    def _get_kcorrections(self, sed, sed_filename, redshift):
+        &#34;&#34;&#34;
+        Cache the k-correction factors and return
+        &#34;&#34;&#34;
+        attr_name = sed_filename.split(&#39;.&#39;)[0] + &#39;-kcorrect_dict-&#39; + str(redshift*100).split(&#39;.&#39;)[0]
+        if hasattr(self, attr_name):
+            return [getattr(self, attr_name)[b] for b in self.bands]
+        else:
+            peak_sed = sed[sed[&#39;NITE&#39;].values == self._get_closest_nite(np.unique(sed[&#39;NITE&#39;].values), 0)].copy().reset_index(drop=True)
+            k_corrections = [self._get_kcorrect(peak_sed, band, redshift) for band in self.bands]
+            setattr(self, attr_name, {b: k for b, k in zip(self.bands, k_corrections)})
+            return k_corrections
+        
         
     def _get_distance_modulus(self, redshift, cosmo):
         &#34;&#34;&#34;
@@ -707,19 +807,12 @@ <h2 id="args">Args</h2>
         :param redshift: the redshift of the source
         :param frame: chose from [&#39;REST&#39;, &#39;OBS&#39;] to choose the rest frame or the observer frame
         :return: flux: the measured flux from the source through the filter
-        &#34;&#34;&#34;
-        # Tighten bounds for accurate integration
-        lower_bound = eval(&#39;self._{0}_obs_frame_freq_min&#39;.format(band))
-        upper_bound = eval(&#39;self._{0}_obs_frame_freq_max&#39;.format(band))        
-        frequency_arr = np.linspace(lower_bound, upper_bound, 100000)
-        
-        # Make an interpolated version of the integrand
-        interpolated_sed = interp1d(sed[&#39;FREQUENCY_{0}&#39;.format(frame)].values, sed[&#39;FLUX&#39;].values, fill_value=0.0)
-        integrand = eval(&#39;self.{0}_transmission_frequency(frequency_arr) * interpolated_sed(frequency_arr) / frequency_arr&#39;.format(band))
-        interpolated_integrand = interp1d(frequency_arr, integrand, fill_value=0.0)
-               
-        # Integrate and return
-        return quad(interpolated_integrand, lower_bound, upper_bound, limit=500)[0]
+        &#34;&#34;&#34;     
+        frequency_arr = sed[&#39;FREQUENCY_{0}&#39;.format(frame)].values
+        delta_frequencies = np.diff(frequency_arr) * -1.0
+        integrand = eval(&#34;self.{0}_transmission_frequency(frequency_arr) * sed[&#39;FLUX&#39;].values / frequency_arr&#34;.format(band))
+        average_integrands = 0.5 * np.diff(integrand) + integrand[0:-1]
+        return np.sum(delta_frequencies * average_integrands)
     
     def _get_closest_nite(self, unique_nites, nite):
         &#34;&#34;&#34;
@@ -729,15 +822,21 @@ <h2 id="args">Args</h2>
         :param nite: the nite you wish to find the closest neighbor for
         :return: closest_nite: the closest nite in the sed to the given nite
         &#34;&#34;&#34;
-        return unique_nites[np.argmin(np.abs(nite - unique_nites))]
+        
+        ## If nite not in the sed, (but within range) set nite to the closest nite in the sed
+        ## If nite is outside range, keep the same
+        if nite &gt; unique_nites.max() or nite &lt; unique_nites.min():
+            return nite
+        else:
+            return unique_nites[np.argmin(np.abs(nite - unique_nites))]
 
-    def gen_variable(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_variable(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a random variable light curve
 
         Args:
             redshift (float): ignored 
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for    
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey    
             sed_filename (str): ignored
             cosmo (astropy.cosmology): ignored
 
@@ -751,22 +850,22 @@ <h2 id="args">Args</h2>
         output_data = []
         central_mag = random.uniform(12.0, 23.0)
         colors = {band: mag for band, mag in zip(self.bands, np.random.uniform(low=-2.0, high=2.0, size=len(self.bands)))}
-        for nite in nites:
-            central_mag = random.uniform(central_mag - 1.0, central_mag + 1.0)
-            for band in self.bands:
+        for band in self.bands:
+            for nite in nite_dict[band]:
+                central_mag = random.uniform(central_mag - 1.0, central_mag + 1.0)
                 output_data.append([nite, band, central_mag + colors[band]])
 
         return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols),
                 &#39;obj_type&#39;: &#39;Variable&#39;,
                 &#39;sed&#39;: &#39;Variable&#39;}
     
-    def gen_flat(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_flat(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a random flat light curve.
         
         Args:
             redshift (float): ignored
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey
             sed_filename (str): ignored
             cosmo (astropy.cosmology): ignored
 
@@ -780,35 +879,36 @@ <h2 id="args">Args</h2>
         central_mag = random.uniform(12.0, 23.0)
         mags = {band: mag for band, mag in zip(self.bands, central_mag + np.random.uniform(low=-2.0, high=2.0, size=len(self.bands)))}
         output_data = []
-        for nite in nites:
-            for band in self.bands:
+        for band in self.bands:
+            for nite in nite_dict[band]:
                 output_data.append([nite, band, mags[band]])
 
         return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols),
                 &#39;obj_type&#39;: &#39;Flat&#39;,
                 &#39;sed&#39;: &#39;Flat&#39;}
 
-    def gen_static(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_static(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Make a static source capable of having time-series data by introducing a mag=99 source
         on each NITE of the simulation.
 
         Args:
             redshift (float): ignored 
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey
             sed_filename (str): ignored                                                                                                                                                               
             cosmo (astropy.cosmology): ignored                                                                                                                                                                                            
         Returns:
             lc_dict: a dictionary with keys [&#39;lc, &#39;obj_type&#39;, &#39;sed&#39;]
               - &#39;lc&#39; contains a dataframe of the light from the object
               - &#39;obj_type&#39; contains a string for the type of object. Will always be &#39;Static&#39; here
-              - &#39;sed&#39; contains the filename of the sed used. Will always be &#39;Flat&#39; here                                                                                                                        &#34;&#34;&#34;
+              - &#39;sed&#39; contains the filename of the sed used. Will always be &#39;Flat&#39; here     
+        &#34;&#34;&#34;
         output_data_cols = [&#39;NITE&#39;, &#39;BAND&#39;, &#39;MAG&#39;]
         central_mag = 99.0
         mags = {band: central_mag for band in self.bands}
         output_data = []
-        for nite in nites:
-            for band in self.bands:
+        for band in self.bands:
+            for nite in nite_dict[band]:
                 output_data.append([nite, band, mags[band]])
 
         return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols),
@@ -817,13 +917,13 @@ <h2 id="args">Args</h2>
 
 
         
-    def gen_variablenoise(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_variablenoise(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34; 
         Generate a variable light curve with small random noise
 
         Args:
             redshift (float): ignored
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey
             sed_filename (str): ignored
             cosmo (astropy.cosmology): ignored
 
@@ -833,7 +933,7 @@ <h2 id="args">Args</h2>
               - &#39;obj_type&#39; contains a string for the type of object. Will always be &#39;VariableNoise&#39; here
               - &#39;sed&#39; contains the filename of the sed used. Will always be &#39;VariableNoise&#39; here              
         &#34;&#34;&#34;
-        noiseless_lc_dict = self.gen_variable(redshift, nites)
+        noiseless_lc_dict = self.gen_variable(redshift, nite_dict)
         noise = np.random.normal(loc=0, scale=0.25, size=noiseless_lc_dict[&#39;lc&#39;].shape[0])
         noiseless_lc_dict[&#39;lc&#39;][&#39;MAG&#39;] = noiseless_lc_dict[&#39;lc&#39;][&#39;MAG&#39;].values + noise
         noiseless_lc_dict[&#39;obj_type&#39;] = &#39;VariableNoise&#39;
@@ -841,13 +941,13 @@ <h2 id="args">Args</h2>
         return noiseless_lc_dict
 
     
-    def gen_flatnoise(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_flatnoise(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a flat light curve will small random noise
 
         Args:
             redshift (float): ignored
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey
             sed_filename (str): ignored
             cosmo (astropy.cosmology): ignored
 
@@ -857,20 +957,20 @@ <h2 id="args">Args</h2>
               - &#39;obj_type&#39; contains a string for the type of object. Will always be &#39;FlatNoise&#39; here
               - &#39;sed&#39; contains the filename of the sed used. Will always be &#39;FlatNoise&#39; here              
         &#34;&#34;&#34;
-        noiseless_lc_dict = self.gen_flat(redshift, nites)
+        noiseless_lc_dict = self.gen_flat(redshift, nite_dict)
         noise = np.random.normal(loc=0, scale=0.25, size=noiseless_lc_dict[&#39;lc&#39;].shape[0])
         noiseless_lc_dict[&#39;lc&#39;][&#39;MAG&#39;] = noiseless_lc_dict[&#39;lc&#39;][&#39;MAG&#39;].values + noise
         noiseless_lc_dict[&#39;obj_type&#39;] = &#39;FlatNoise&#39;
         noiseless_lc_dict[&#39;sed&#39;] = &#39;FlatNoise&#39;
         return noiseless_lc_dict
         
-    def gen_user(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_user(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a light curve from a user-specidied SED
 
         Args:
             redshift (float): the redshift of the source
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
             sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
             sed_filename (str): filename containing the time-series sed you want to use 
             cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -881,18 +981,28 @@ <h2 id="args">Args</h2>
               - &#39;obj_type&#39; contains a string for the type of object. Will always be &lt;sed_filename&gt; here 
               - &#39;sed&#39; contains the filename of the sed used  
         &#34;&#34;&#34;
-        if not sed:
-            sed = self._read_sed(&#39;seds/user/&#39; + sed_filename)
+        if sed is None:
+            if sed_filename.startswith(&#39;seds/user/&#39;):
+                attr_name = sed_filename.split(&#39;.&#39;)[0]
+            else:
+                attr_name = &#39;seds/user/&#39; + sed_filename.split(&#39;.&#39;)[0]
+                sed_filename = &#39;seds/user/&#39; + sed_filename
+                
+            if hasattr(self, attr_name):
+                sed = getattr(self, attr_name)
+            else:
+                sed = self._read_sed(sed_filename)
+                setattr(self, attr_name, sed)
 
-        return self.gen_lc_from_sed(redshift, nites, sed, sed_filename, sed_filename, cosmo=cosmo)
+        return self.gen_lc_from_sed(redshift, nite_dict, sed, sed_filename, sed_filename, cosmo=cosmo)
 
-    def gen_kn(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_kn(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a GW170817-like light curve.
 
         Args:
             redshift (float): the redshift of the source
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
             sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
             sed_filename (str): filename containing the time-series sed you want to use 
             cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -905,19 +1015,23 @@ <h2 id="args">Args</h2>
         &#34;&#34;&#34;
 
         sed_filename = &#39;seds/kn/kn.SED&#39;
-        if not sed:
-            sed = self._read_sed(sed_filename)
-
-        return self.gen_lc_from_sed(redshift, nites, sed, &#39;KN&#39;, sed_filename, cosmo=cosmo)
+        if sed is None:
+            attr_name = sed_filename.split(&#39;.&#39;)[0]
+            if hasattr(self, attr_name):
+                sed = getattr(self, attr_name)
+            else:
+                sed = self._read_sed(sed_filename)
+                setattr(self, attr_name, sed)
+                
+        return self.gen_lc_from_sed(redshift, nite_dict, sed, &#39;KN&#39;, sed_filename, cosmo=cosmo)
     
-    def gen_ia(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_ia(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a SN-Ia light curve.
-        
 
         Args:
             redshift (float): the redshift of the source
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
             sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
             sed_filename (str): filename containing the time-series sed you want to use 
             cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -930,23 +1044,32 @@ <h2 id="args">Args</h2>
         &#34;&#34;&#34;
         
         # Read rest-frame sed if not supplied as argument
-        if not sed:
-            if sed_filename:
-                sed = self._read_sed(&#39;seds/ia/&#39; + sed_filename)
-            else:
+        if sed is None:
+            if sed_filename is None:
                 sed_filename = random.choice(self.ia_sed_files)
+            
+            if sed_filename.startswith(&#39;seds/ia/&#39;):
+                attr_name = sed_filename.split(&#39;.&#39;)[0]
+            else:
+                attr_name = &#39;seds/ia/&#39; + sed_filename.split(&#39;.&#39;)[0]
+                sed_filename = &#39;seds/ia/&#39; + sed_filename
+
+            if hasattr(self, attr_name):
+                sed = getattr(self, attr_name)
+            else:
                 sed = self._read_sed(sed_filename)
+                setattr(self, attr_name, sed)
                 
         # Trigger the lc generation function on this sed
-        return self.gen_lc_from_sed(redshift, nites, sed, &#39;Ia&#39;, sed_filename, cosmo=cosmo)
+        return self.gen_lc_from_sed(redshift, nite_dict, sed, &#39;Ia&#39;, sed_filename, cosmo=cosmo)
     
-    def gen_cc(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+    def gen_cc(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
         &#34;&#34;&#34;
         Generate a SN-CC light curve
         
         Args:
             redshift (float): the redshift of the source
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
             sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
             sed_filename (str): filename containing the time-series sed you want to use 
             cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -959,26 +1082,35 @@ <h2 id="args">Args</h2>
         &#34;&#34;&#34;
 
         # If sed not specified, choose sed based on weight map
-        if not sed:
-            if sed_filename:
-                sed = self._read_sed(&#39;seds/cc/&#39; + sed_filename)
-            else:
+        if sed is None:
+            if sed_filename is None:
                 sed_filename = random.choices(self.cc_sed_files, weights=self.cc_weights, k=1)[0]
+
+            if sed_filename.startswith(&#39;seds/cc/&#39;):
+                attr_name = sed_filename.split(&#39;.&#39;)[0]
+            else:
+                attr_name = &#39;seds/cc/&#39; + sed_filename.split(&#39;.&#39;)[0]
+                sed_filename = &#39;seds/cc/&#39; + sed_filename
+                    
+            if hasattr(self, attr_name):
+                sed = getattr(self, attr_name)
+            else:
                 sed = self._read_sed(sed_filename)
+                setattr(self, attr_name, sed)
         
         # Get the type of SN-CC
         obj_type = self.cc_info_df[&#39;SNTYPE&#39;].values[self.cc_info_df[&#39;SED&#39;].values == sed_filename.split(&#39;/&#39;)[-1].split(&#39;.&#39;)[0]][0]
         
         # Trigger the lc generation function on this sed
-        return self.gen_lc_from_sed(redshift, nites, sed, obj_type, sed_filename, cosmo=cosmo)
+        return self.gen_lc_from_sed(redshift, nite_dict, sed, obj_type, sed_filename, cosmo=cosmo)
                 
-    def gen_lc_from_sed(self, redshift, nites, sed, obj_type, sed_filename, cosmo=None):
+    def gen_lc_from_sed(self, redshift, nite_dict, sed, obj_type, sed_filename, cosmo=None):
         &#34;&#34;&#34;
         Generate a light curve based on a time-series sed.
         
         Args:
             redshift (float): the redshift of the source
-            nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+            nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
             sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
             sed_filename (str): filename containing the time-series sed you want to use 
             cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -990,15 +1122,17 @@ <h2 id="args">Args</h2>
               - &#39;sed&#39; contains the filename of the sed used  
         &#34;&#34;&#34;
         
-        # If nite not in the sed, set nite to the closest nite in the sed
-        useable_nites = []
+        # Adjust nites
+        nites = {}
         sed_nites = np.unique(sed[&#39;NITE&#39;].values)
-        for nite in nites:
-            if nite not in sed_nites:
-                useable_nites.append(self._get_closest_nite(sed_nites, nite))
-            else:
-                useable_nites.append(nite)
-        nites = useable_nites
+        for band, cad_nites in nite_dict.items():
+            useable_nites = []
+            for nite in cad_nites:
+                if nite not in sed_nites:
+                    useable_nites.append(self._get_closest_nite(sed_nites, nite))
+                else:
+                    useable_nites.append(nite)
+            nites[band] = useable_nites
             
         # Redshift the sed frequencies and wavelengths
         sed[&#39;WAVELENGTH_OBS&#39;] = (1.0 + redshift) * sed[&#39;WAVELENGTH_REST&#39;].values
@@ -1011,38 +1145,38 @@ <h2 id="args">Args</h2>
         distance_modulus = self._get_distance_modulus(redshift, cosmo=cosmo)
         
         # Calculate k-correction at peak
-        peak_sed = sed[sed[&#39;NITE&#39;].values == self._get_closest_nite(np.unique(sed[&#39;NITE&#39;].values), 0)].copy().reset_index(drop=True)
-        k_corrections = [self._get_kcorrect(peak_sed, band, redshift) for band in self.bands]
+        k_corrections = self._get_kcorrections(sed, sed_filename, redshift)
         
         # On each nite, in each band, calculate the absolute mag
         output_data = []
         output_data_cols = [&#39;NITE&#39;, &#39;BAND&#39;, &#39;MAG&#39;]
-        for nite in nites:
-            nite_sed = sed[sed[&#39;NITE&#39;].values == nite].copy().reset_index(drop=True)
-            
-            # Apply factors to calculate absolute mag
-            nite_sed[&#39;FLUX&#39;] = (cosmo.luminosity_distance(redshift).value * 10 ** 6 / 10) ** 2 / (1 + redshift) * nite_sed[&#39;FLUX&#39;].values
-            nite_sed[&#39;FREQUENCY_REST&#39;] = nite_sed[&#39;FREQUENCY_REST&#39;].values / (1. + redshift)
-            
-            # Convert to AB Magnitude system
-            norm_sed = nite_sed.copy()
-            norm_sed[&#39;FLUX&#39;] = 3631.0
+        
+        for band, k_correction in zip(self.bands, k_corrections):
             
-            for band, k_correction in zip(self.bands, k_corrections):
+            for nite in nites[band]:
+                nite_sed = sed[sed[&#39;NITE&#39;].values == nite].copy().reset_index(drop=True)
                 
+                # Flux is zero if requested nite is noe in sed
+                if len(nite_sed) == 0:
+                    output_data.append([nite, band, 99.0])
+                    continue
+                
+                # Apply factors to calculate absolute mag
+                nite_sed[&#39;FLUX&#39;] = (cosmo.luminosity_distance(redshift).value * 10 ** 6 / 10) ** 2 / (1 + redshift) * nite_sed[&#39;FLUX&#39;].values
+                nite_sed[&#39;FREQUENCY_REST&#39;] = nite_sed[&#39;FREQUENCY_REST&#39;].values / (1. + redshift)
+            
                 # Calculate the apparent magnitude
-                norm = self._integrate_through_band(norm_sed, band, redshift, frame=&#39;REST&#39;)
-                absolute_ab_mag = self._integrate_through_band(nite_sed, band, redshift, frame=&#39;REST&#39;) / norm
+                absolute_ab_mag = self._integrate_through_band(nite_sed, band, redshift, frame=&#39;REST&#39;) / self.norm_dict[band]
                 output_data.append([nite, band, -2.5 * np.log10(absolute_ab_mag) + distance_modulus + k_correction])
                 
-        return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols).replace(np.nan, 30.0, inplace=False),
+        return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols).replace(np.nan, 99.0, inplace=False),
                 &#39;obj_type&#39;: obj_type,
                 &#39;sed&#39;: sed_filename}</code></pre>
 </details>
 <h3>Methods</h3>
 <dl>
 <dt id="deeplenstronomy.timeseries.LCGen.gen_cc"><code class="name flex">
-<span>def <span class="ident">gen_cc</span></span>(<span>self, redshift, nites, sed=None, sed_filename=None, cosmo=None)</span>
+<span>def <span class="ident">gen_cc</span></span>(<span>self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Generate a SN-CC light curve</p>
@@ -1050,8 +1184,7 @@ <h2 id="args">Args</h2>
 <dl>
 <dt><strong><code>redshift</code></strong> :&ensp;<code>float</code></dt>
 <dd>the redshift of the source</dd>
-<dt><strong><code>nites</code></strong> :&ensp;<code>List[int]</code></dt>
-<dd>a list of night relative to peak you want to obtain a magnitude for </dd>
+<dt>nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey</dt>
 <dt><strong><code>sed</code></strong> :&ensp;<code>None</code> or <code>pandas.DataFrame</code>, optional, default=<code>None</code></dt>
 <dd>a dataframe containing the sed of the SN </dd>
 <dt><strong><code>sed_filename</code></strong> :&ensp;<code>str</code></dt>
@@ -1071,13 +1204,13 @@ <h2 id="returns">Returns</h2>
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def gen_cc(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+<pre><code class="python">def gen_cc(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
     &#34;&#34;&#34;
     Generate a SN-CC light curve
     
     Args:
         redshift (float): the redshift of the source
-        nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+        nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
         sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
         sed_filename (str): filename containing the time-series sed you want to use 
         cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -1090,22 +1223,31 @@ <h2 id="returns">Returns</h2>
     &#34;&#34;&#34;
 
     # If sed not specified, choose sed based on weight map
-    if not sed:
-        if sed_filename:
-            sed = self._read_sed(&#39;seds/cc/&#39; + sed_filename)
-        else:
+    if sed is None:
+        if sed_filename is None:
             sed_filename = random.choices(self.cc_sed_files, weights=self.cc_weights, k=1)[0]
+
+        if sed_filename.startswith(&#39;seds/cc/&#39;):
+            attr_name = sed_filename.split(&#39;.&#39;)[0]
+        else:
+            attr_name = &#39;seds/cc/&#39; + sed_filename.split(&#39;.&#39;)[0]
+            sed_filename = &#39;seds/cc/&#39; + sed_filename
+                
+        if hasattr(self, attr_name):
+            sed = getattr(self, attr_name)
+        else:
             sed = self._read_sed(sed_filename)
+            setattr(self, attr_name, sed)
     
     # Get the type of SN-CC
     obj_type = self.cc_info_df[&#39;SNTYPE&#39;].values[self.cc_info_df[&#39;SED&#39;].values == sed_filename.split(&#39;/&#39;)[-1].split(&#39;.&#39;)[0]][0]
     
     # Trigger the lc generation function on this sed
-    return self.gen_lc_from_sed(redshift, nites, sed, obj_type, sed_filename, cosmo=cosmo)</code></pre>
+    return self.gen_lc_from_sed(redshift, nite_dict, sed, obj_type, sed_filename, cosmo=cosmo)</code></pre>
 </details>
 </dd>
 <dt id="deeplenstronomy.timeseries.LCGen.gen_flat"><code class="name flex">
-<span>def <span class="ident">gen_flat</span></span>(<span>self, redshift, nites, sed=None, sed_filename=None, cosmo=None)</span>
+<span>def <span class="ident">gen_flat</span></span>(<span>self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Generate a random flat light curve.</p>
@@ -1113,8 +1255,7 @@ <h2 id="args">Args</h2>
 <dl>
 <dt><strong><code>redshift</code></strong> :&ensp;<code>float</code></dt>
 <dd>ignored</dd>
-<dt><strong><code>nites</code></strong> :&ensp;<code>List[int]</code></dt>
-<dd>a list of night relative to peak you want to obtain a magnitude for</dd>
+<dt>nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey</dt>
 <dt><strong><code>sed_filename</code></strong> :&ensp;<code>str</code></dt>
 <dd>ignored</dd>
 <dt><strong><code>cosmo</code></strong> :&ensp;<code>astropy.cosmology</code></dt>
@@ -1132,13 +1273,13 @@ <h2 id="returns">Returns</h2>
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def gen_flat(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+<pre><code class="python">def gen_flat(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
     &#34;&#34;&#34;
     Generate a random flat light curve.
     
     Args:
         redshift (float): ignored
-        nites (List[int]): a list of night relative to peak you want to obtain a magnitude for
+        nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey
         sed_filename (str): ignored
         cosmo (astropy.cosmology): ignored
 
@@ -1152,8 +1293,8 @@ <h2 id="returns">Returns</h2>
     central_mag = random.uniform(12.0, 23.0)
     mags = {band: mag for band, mag in zip(self.bands, central_mag + np.random.uniform(low=-2.0, high=2.0, size=len(self.bands)))}
     output_data = []
-    for nite in nites:
-        for band in self.bands:
+    for band in self.bands:
+        for nite in nite_dict[band]:
             output_data.append([nite, band, mags[band]])
 
     return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols),
@@ -1162,7 +1303,7 @@ <h2 id="returns">Returns</h2>
 </details>
 </dd>
 <dt id="deeplenstronomy.timeseries.LCGen.gen_flatnoise"><code class="name flex">
-<span>def <span class="ident">gen_flatnoise</span></span>(<span>self, redshift, nites, sed=None, sed_filename=None, cosmo=None)</span>
+<span>def <span class="ident">gen_flatnoise</span></span>(<span>self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Generate a flat light curve will small random noise</p>
@@ -1170,8 +1311,7 @@ <h2 id="args">Args</h2>
 <dl>
 <dt><strong><code>redshift</code></strong> :&ensp;<code>float</code></dt>
 <dd>ignored</dd>
-<dt><strong><code>nites</code></strong> :&ensp;<code>List[int]</code></dt>
-<dd>a list of night relative to peak you want to obtain a magnitude for</dd>
+<dt>nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey</dt>
 <dt><strong><code>sed_filename</code></strong> :&ensp;<code>str</code></dt>
 <dd>ignored</dd>
 <dt><strong><code>cosmo</code></strong> :&ensp;<code>astropy.cosmology</code></dt>
@@ -1189,13 +1329,13 @@ <h2 id="returns">Returns</h2>
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def gen_flatnoise(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+<pre><code class="python">def gen_flatnoise(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
     &#34;&#34;&#34;
     Generate a flat light curve will small random noise
 
     Args:
         redshift (float): ignored
-        nites (List[int]): a list of night relative to peak you want to obtain a magnitude for
+        nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey
         sed_filename (str): ignored
         cosmo (astropy.cosmology): ignored
 
@@ -1205,7 +1345,7 @@ <h2 id="returns">Returns</h2>
           - &#39;obj_type&#39; contains a string for the type of object. Will always be &#39;FlatNoise&#39; here
           - &#39;sed&#39; contains the filename of the sed used. Will always be &#39;FlatNoise&#39; here              
     &#34;&#34;&#34;
-    noiseless_lc_dict = self.gen_flat(redshift, nites)
+    noiseless_lc_dict = self.gen_flat(redshift, nite_dict)
     noise = np.random.normal(loc=0, scale=0.25, size=noiseless_lc_dict[&#39;lc&#39;].shape[0])
     noiseless_lc_dict[&#39;lc&#39;][&#39;MAG&#39;] = noiseless_lc_dict[&#39;lc&#39;][&#39;MAG&#39;].values + noise
     noiseless_lc_dict[&#39;obj_type&#39;] = &#39;FlatNoise&#39;
@@ -1214,7 +1354,7 @@ <h2 id="returns">Returns</h2>
 </details>
 </dd>
 <dt id="deeplenstronomy.timeseries.LCGen.gen_ia"><code class="name flex">
-<span>def <span class="ident">gen_ia</span></span>(<span>self, redshift, nites, sed=None, sed_filename=None, cosmo=None)</span>
+<span>def <span class="ident">gen_ia</span></span>(<span>self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Generate a SN-Ia light curve.</p>
@@ -1222,8 +1362,7 @@ <h2 id="args">Args</h2>
 <dl>
 <dt><strong><code>redshift</code></strong> :&ensp;<code>float</code></dt>
 <dd>the redshift of the source</dd>
-<dt><strong><code>nites</code></strong> :&ensp;<code>List[int]</code></dt>
-<dd>a list of night relative to peak you want to obtain a magnitude for </dd>
+<dt>nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey</dt>
 <dt><strong><code>sed</code></strong> :&ensp;<code>None</code> or <code>pandas.DataFrame</code>, optional, default=<code>None</code></dt>
 <dd>a dataframe containing the sed of the SN </dd>
 <dt><strong><code>sed_filename</code></strong> :&ensp;<code>str</code></dt>
@@ -1243,14 +1382,13 @@ <h2 id="returns">Returns</h2>
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def gen_ia(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+<pre><code class="python">def gen_ia(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
     &#34;&#34;&#34;
     Generate a SN-Ia light curve.
-    
 
     Args:
         redshift (float): the redshift of the source
-        nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+        nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
         sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
         sed_filename (str): filename containing the time-series sed you want to use 
         cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -1263,19 +1401,28 @@ <h2 id="returns">Returns</h2>
     &#34;&#34;&#34;
     
     # Read rest-frame sed if not supplied as argument
-    if not sed:
-        if sed_filename:
-            sed = self._read_sed(&#39;seds/ia/&#39; + sed_filename)
-        else:
+    if sed is None:
+        if sed_filename is None:
             sed_filename = random.choice(self.ia_sed_files)
+        
+        if sed_filename.startswith(&#39;seds/ia/&#39;):
+            attr_name = sed_filename.split(&#39;.&#39;)[0]
+        else:
+            attr_name = &#39;seds/ia/&#39; + sed_filename.split(&#39;.&#39;)[0]
+            sed_filename = &#39;seds/ia/&#39; + sed_filename
+
+        if hasattr(self, attr_name):
+            sed = getattr(self, attr_name)
+        else:
             sed = self._read_sed(sed_filename)
+            setattr(self, attr_name, sed)
             
     # Trigger the lc generation function on this sed
-    return self.gen_lc_from_sed(redshift, nites, sed, &#39;Ia&#39;, sed_filename, cosmo=cosmo)</code></pre>
+    return self.gen_lc_from_sed(redshift, nite_dict, sed, &#39;Ia&#39;, sed_filename, cosmo=cosmo)</code></pre>
 </details>
 </dd>
 <dt id="deeplenstronomy.timeseries.LCGen.gen_kn"><code class="name flex">
-<span>def <span class="ident">gen_kn</span></span>(<span>self, redshift, nites, sed=None, sed_filename=None, cosmo=None)</span>
+<span>def <span class="ident">gen_kn</span></span>(<span>self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Generate a GW170817-like light curve.</p>
@@ -1283,8 +1430,7 @@ <h2 id="args">Args</h2>
 <dl>
 <dt><strong><code>redshift</code></strong> :&ensp;<code>float</code></dt>
 <dd>the redshift of the source</dd>
-<dt><strong><code>nites</code></strong> :&ensp;<code>List[int]</code></dt>
-<dd>a list of night relative to peak you want to obtain a magnitude for </dd>
+<dt>nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey</dt>
 <dt><strong><code>sed</code></strong> :&ensp;<code>None</code> or <code>pandas.DataFrame</code>, optional, default=<code>None</code></dt>
 <dd>a dataframe containing the sed of the SN </dd>
 <dt><strong><code>sed_filename</code></strong> :&ensp;<code>str</code></dt>
@@ -1304,13 +1450,13 @@ <h2 id="returns">Returns</h2>
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def gen_kn(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+<pre><code class="python">def gen_kn(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
     &#34;&#34;&#34;
     Generate a GW170817-like light curve.
 
     Args:
         redshift (float): the redshift of the source
-        nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+        nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
         sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
         sed_filename (str): filename containing the time-series sed you want to use 
         cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -1323,14 +1469,19 @@ <h2 id="returns">Returns</h2>
     &#34;&#34;&#34;
 
     sed_filename = &#39;seds/kn/kn.SED&#39;
-    if not sed:
-        sed = self._read_sed(sed_filename)
-
-    return self.gen_lc_from_sed(redshift, nites, sed, &#39;KN&#39;, sed_filename, cosmo=cosmo)</code></pre>
+    if sed is None:
+        attr_name = sed_filename.split(&#39;.&#39;)[0]
+        if hasattr(self, attr_name):
+            sed = getattr(self, attr_name)
+        else:
+            sed = self._read_sed(sed_filename)
+            setattr(self, attr_name, sed)
+            
+    return self.gen_lc_from_sed(redshift, nite_dict, sed, &#39;KN&#39;, sed_filename, cosmo=cosmo)</code></pre>
 </details>
 </dd>
 <dt id="deeplenstronomy.timeseries.LCGen.gen_lc_from_sed"><code class="name flex">
-<span>def <span class="ident">gen_lc_from_sed</span></span>(<span>self, redshift, nites, sed, obj_type, sed_filename, cosmo=None)</span>
+<span>def <span class="ident">gen_lc_from_sed</span></span>(<span>self, redshift, nite_dict, sed, obj_type, sed_filename, cosmo=None)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Generate a light curve based on a time-series sed.</p>
@@ -1338,8 +1489,7 @@ <h2 id="args">Args</h2>
 <dl>
 <dt><strong><code>redshift</code></strong> :&ensp;<code>float</code></dt>
 <dd>the redshift of the source</dd>
-<dt><strong><code>nites</code></strong> :&ensp;<code>List[int]</code></dt>
-<dd>a list of night relative to peak you want to obtain a magnitude for </dd>
+<dt>nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey</dt>
 <dt><strong><code>sed</code></strong> :&ensp;<code>None</code> or <code>pandas.DataFrame</code>, optional, default=<code>None</code></dt>
 <dd>a dataframe containing the sed of the SN </dd>
 <dt><strong><code>sed_filename</code></strong> :&ensp;<code>str</code></dt>
@@ -1359,13 +1509,13 @@ <h2 id="returns">Returns</h2>
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def gen_lc_from_sed(self, redshift, nites, sed, obj_type, sed_filename, cosmo=None):
+<pre><code class="python">def gen_lc_from_sed(self, redshift, nite_dict, sed, obj_type, sed_filename, cosmo=None):
     &#34;&#34;&#34;
     Generate a light curve based on a time-series sed.
     
     Args:
         redshift (float): the redshift of the source
-        nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+        nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
         sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
         sed_filename (str): filename containing the time-series sed you want to use 
         cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -1377,15 +1527,17 @@ <h2 id="returns">Returns</h2>
           - &#39;sed&#39; contains the filename of the sed used  
     &#34;&#34;&#34;
     
-    # If nite not in the sed, set nite to the closest nite in the sed
-    useable_nites = []
+    # Adjust nites
+    nites = {}
     sed_nites = np.unique(sed[&#39;NITE&#39;].values)
-    for nite in nites:
-        if nite not in sed_nites:
-            useable_nites.append(self._get_closest_nite(sed_nites, nite))
-        else:
-            useable_nites.append(nite)
-    nites = useable_nites
+    for band, cad_nites in nite_dict.items():
+        useable_nites = []
+        for nite in cad_nites:
+            if nite not in sed_nites:
+                useable_nites.append(self._get_closest_nite(sed_nites, nite))
+            else:
+                useable_nites.append(nite)
+        nites[band] = useable_nites
         
     # Redshift the sed frequencies and wavelengths
     sed[&#39;WAVELENGTH_OBS&#39;] = (1.0 + redshift) * sed[&#39;WAVELENGTH_REST&#39;].values
@@ -1398,37 +1550,37 @@ <h2 id="returns">Returns</h2>
     distance_modulus = self._get_distance_modulus(redshift, cosmo=cosmo)
     
     # Calculate k-correction at peak
-    peak_sed = sed[sed[&#39;NITE&#39;].values == self._get_closest_nite(np.unique(sed[&#39;NITE&#39;].values), 0)].copy().reset_index(drop=True)
-    k_corrections = [self._get_kcorrect(peak_sed, band, redshift) for band in self.bands]
+    k_corrections = self._get_kcorrections(sed, sed_filename, redshift)
     
     # On each nite, in each band, calculate the absolute mag
     output_data = []
     output_data_cols = [&#39;NITE&#39;, &#39;BAND&#39;, &#39;MAG&#39;]
-    for nite in nites:
-        nite_sed = sed[sed[&#39;NITE&#39;].values == nite].copy().reset_index(drop=True)
-        
-        # Apply factors to calculate absolute mag
-        nite_sed[&#39;FLUX&#39;] = (cosmo.luminosity_distance(redshift).value * 10 ** 6 / 10) ** 2 / (1 + redshift) * nite_sed[&#39;FLUX&#39;].values
-        nite_sed[&#39;FREQUENCY_REST&#39;] = nite_sed[&#39;FREQUENCY_REST&#39;].values / (1. + redshift)
-        
-        # Convert to AB Magnitude system
-        norm_sed = nite_sed.copy()
-        norm_sed[&#39;FLUX&#39;] = 3631.0
+    
+    for band, k_correction in zip(self.bands, k_corrections):
         
-        for band, k_correction in zip(self.bands, k_corrections):
+        for nite in nites[band]:
+            nite_sed = sed[sed[&#39;NITE&#39;].values == nite].copy().reset_index(drop=True)
+            
+            # Flux is zero if requested nite is noe in sed
+            if len(nite_sed) == 0:
+                output_data.append([nite, band, 99.0])
+                continue
             
+            # Apply factors to calculate absolute mag
+            nite_sed[&#39;FLUX&#39;] = (cosmo.luminosity_distance(redshift).value * 10 ** 6 / 10) ** 2 / (1 + redshift) * nite_sed[&#39;FLUX&#39;].values
+            nite_sed[&#39;FREQUENCY_REST&#39;] = nite_sed[&#39;FREQUENCY_REST&#39;].values / (1. + redshift)
+        
             # Calculate the apparent magnitude
-            norm = self._integrate_through_band(norm_sed, band, redshift, frame=&#39;REST&#39;)
-            absolute_ab_mag = self._integrate_through_band(nite_sed, band, redshift, frame=&#39;REST&#39;) / norm
+            absolute_ab_mag = self._integrate_through_band(nite_sed, band, redshift, frame=&#39;REST&#39;) / self.norm_dict[band]
             output_data.append([nite, band, -2.5 * np.log10(absolute_ab_mag) + distance_modulus + k_correction])
             
-    return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols).replace(np.nan, 30.0, inplace=False),
+    return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols).replace(np.nan, 99.0, inplace=False),
             &#39;obj_type&#39;: obj_type,
             &#39;sed&#39;: sed_filename}</code></pre>
 </details>
 </dd>
 <dt id="deeplenstronomy.timeseries.LCGen.gen_static"><code class="name flex">
-<span>def <span class="ident">gen_static</span></span>(<span>self, redshift, nites, sed=None, sed_filename=None, cosmo=None)</span>
+<span>def <span class="ident">gen_static</span></span>(<span>self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Make a static source capable of having time-series data by introducing a mag=99 source
@@ -1437,8 +1589,7 @@ <h2 id="args">Args</h2>
 <dl>
 <dt><strong><code>redshift</code></strong> :&ensp;<code>float</code></dt>
 <dd>ignored </dd>
-<dt><strong><code>nites</code></strong> :&ensp;<code>List[int]</code></dt>
-<dd>a list of night relative to peak you want to obtain a magnitude for</dd>
+<dt>nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey</dt>
 <dt><strong><code>sed_filename</code></strong> :&ensp;<code>str</code></dt>
 <dd>ignored
 </dd>
@@ -1458,27 +1609,28 @@ <h2 id="returns">Returns</h2>
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def gen_static(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+<pre><code class="python">def gen_static(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
     &#34;&#34;&#34;
     Make a static source capable of having time-series data by introducing a mag=99 source
     on each NITE of the simulation.
 
     Args:
         redshift (float): ignored 
-        nites (List[int]): a list of night relative to peak you want to obtain a magnitude for
+        nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey
         sed_filename (str): ignored                                                                                                                                                               
         cosmo (astropy.cosmology): ignored                                                                                                                                                                                            
     Returns:
         lc_dict: a dictionary with keys [&#39;lc, &#39;obj_type&#39;, &#39;sed&#39;]
           - &#39;lc&#39; contains a dataframe of the light from the object
           - &#39;obj_type&#39; contains a string for the type of object. Will always be &#39;Static&#39; here
-          - &#39;sed&#39; contains the filename of the sed used. Will always be &#39;Flat&#39; here                                                                                                                        &#34;&#34;&#34;
+          - &#39;sed&#39; contains the filename of the sed used. Will always be &#39;Flat&#39; here     
+    &#34;&#34;&#34;
     output_data_cols = [&#39;NITE&#39;, &#39;BAND&#39;, &#39;MAG&#39;]
     central_mag = 99.0
     mags = {band: central_mag for band in self.bands}
     output_data = []
-    for nite in nites:
-        for band in self.bands:
+    for band in self.bands:
+        for nite in nite_dict[band]:
             output_data.append([nite, band, mags[band]])
 
     return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols),
@@ -1487,7 +1639,7 @@ <h2 id="returns">Returns</h2>
 </details>
 </dd>
 <dt id="deeplenstronomy.timeseries.LCGen.gen_user"><code class="name flex">
-<span>def <span class="ident">gen_user</span></span>(<span>self, redshift, nites, sed=None, sed_filename=None, cosmo=None)</span>
+<span>def <span class="ident">gen_user</span></span>(<span>self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Generate a light curve from a user-specidied SED</p>
@@ -1495,8 +1647,7 @@ <h2 id="args">Args</h2>
 <dl>
 <dt><strong><code>redshift</code></strong> :&ensp;<code>float</code></dt>
 <dd>the redshift of the source</dd>
-<dt><strong><code>nites</code></strong> :&ensp;<code>List[int]</code></dt>
-<dd>a list of night relative to peak you want to obtain a magnitude for </dd>
+<dt>nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey</dt>
 <dt><strong><code>sed</code></strong> :&ensp;<code>None</code> or <code>pandas.DataFrame</code>, optional, default=<code>None</code></dt>
 <dd>a dataframe containing the sed of the SN </dd>
 <dt><strong><code>sed_filename</code></strong> :&ensp;<code>str</code></dt>
@@ -1516,13 +1667,13 @@ <h2 id="returns">Returns</h2>
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def gen_user(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+<pre><code class="python">def gen_user(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
     &#34;&#34;&#34;
     Generate a light curve from a user-specidied SED
 
     Args:
         redshift (float): the redshift of the source
-        nites (List[int]): a list of night relative to peak you want to obtain a magnitude for 
+        nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey 
         sed (None or pandas.DataFrame, optional, default=None): a dataframe containing the sed of the SN 
         sed_filename (str): filename containing the time-series sed you want to use 
         cosmo (astropy.cosmology): an astropy.cosmology instance used for distance calculations
@@ -1533,14 +1684,24 @@ <h2 id="returns">Returns</h2>
           - &#39;obj_type&#39; contains a string for the type of object. Will always be &lt;sed_filename&gt; here 
           - &#39;sed&#39; contains the filename of the sed used  
     &#34;&#34;&#34;
-    if not sed:
-        sed = self._read_sed(&#39;seds/user/&#39; + sed_filename)
+    if sed is None:
+        if sed_filename.startswith(&#39;seds/user/&#39;):
+            attr_name = sed_filename.split(&#39;.&#39;)[0]
+        else:
+            attr_name = &#39;seds/user/&#39; + sed_filename.split(&#39;.&#39;)[0]
+            sed_filename = &#39;seds/user/&#39; + sed_filename
+            
+        if hasattr(self, attr_name):
+            sed = getattr(self, attr_name)
+        else:
+            sed = self._read_sed(sed_filename)
+            setattr(self, attr_name, sed)
 
-    return self.gen_lc_from_sed(redshift, nites, sed, sed_filename, sed_filename, cosmo=cosmo)</code></pre>
+    return self.gen_lc_from_sed(redshift, nite_dict, sed, sed_filename, sed_filename, cosmo=cosmo)</code></pre>
 </details>
 </dd>
 <dt id="deeplenstronomy.timeseries.LCGen.gen_variable"><code class="name flex">
-<span>def <span class="ident">gen_variable</span></span>(<span>self, redshift, nites, sed=None, sed_filename=None, cosmo=None)</span>
+<span>def <span class="ident">gen_variable</span></span>(<span>self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Generate a random variable light curve</p>
@@ -1548,9 +1709,7 @@ <h2 id="args">Args</h2>
 <dl>
 <dt><strong><code>redshift</code></strong> :&ensp;<code>float</code></dt>
 <dd>ignored </dd>
-<dt><strong><code>nites</code></strong> :&ensp;<code>List[int]</code></dt>
-<dd>a list of night relative to peak you want to obtain a magnitude for
-</dd>
+<dt>nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey</dt>
 <dt><strong><code>sed_filename</code></strong> :&ensp;<code>str</code></dt>
 <dd>ignored</dd>
 <dt><strong><code>cosmo</code></strong> :&ensp;<code>astropy.cosmology</code></dt>
@@ -1569,13 +1728,13 @@ <h2 id="returns">Returns</h2>
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def gen_variable(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+<pre><code class="python">def gen_variable(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
     &#34;&#34;&#34;
     Generate a random variable light curve
 
     Args:
         redshift (float): ignored 
-        nites (List[int]): a list of night relative to peak you want to obtain a magnitude for    
+        nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey    
         sed_filename (str): ignored
         cosmo (astropy.cosmology): ignored
 
@@ -1589,9 +1748,9 @@ <h2 id="returns">Returns</h2>
     output_data = []
     central_mag = random.uniform(12.0, 23.0)
     colors = {band: mag for band, mag in zip(self.bands, np.random.uniform(low=-2.0, high=2.0, size=len(self.bands)))}
-    for nite in nites:
-        central_mag = random.uniform(central_mag - 1.0, central_mag + 1.0)
-        for band in self.bands:
+    for band in self.bands:
+        for nite in nite_dict[band]:
+            central_mag = random.uniform(central_mag - 1.0, central_mag + 1.0)
             output_data.append([nite, band, central_mag + colors[band]])
 
     return {&#39;lc&#39;: pd.DataFrame(data=output_data, columns=output_data_cols),
@@ -1600,7 +1759,7 @@ <h2 id="returns">Returns</h2>
 </details>
 </dd>
 <dt id="deeplenstronomy.timeseries.LCGen.gen_variablenoise"><code class="name flex">
-<span>def <span class="ident">gen_variablenoise</span></span>(<span>self, redshift, nites, sed=None, sed_filename=None, cosmo=None)</span>
+<span>def <span class="ident">gen_variablenoise</span></span>(<span>self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Generate a variable light curve with small random noise</p>
@@ -1608,8 +1767,7 @@ <h2 id="args">Args</h2>
 <dl>
 <dt><strong><code>redshift</code></strong> :&ensp;<code>float</code></dt>
 <dd>ignored</dd>
-<dt><strong><code>nites</code></strong> :&ensp;<code>List[int]</code></dt>
-<dd>a list of night relative to peak you want to obtain a magnitude for</dd>
+<dt>nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey</dt>
 <dt><strong><code>sed_filename</code></strong> :&ensp;<code>str</code></dt>
 <dd>ignored</dd>
 <dt><strong><code>cosmo</code></strong> :&ensp;<code>astropy.cosmology</code></dt>
@@ -1627,13 +1785,13 @@ <h2 id="returns">Returns</h2>
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def gen_variablenoise(self, redshift, nites, sed=None, sed_filename=None, cosmo=None):
+<pre><code class="python">def gen_variablenoise(self, redshift, nite_dict, sed=None, sed_filename=None, cosmo=None):
     &#34;&#34;&#34; 
     Generate a variable light curve with small random noise
 
     Args:
         redshift (float): ignored
-        nites (List[int]): a list of night relative to peak you want to obtain a magnitude for
+        nite_dict (dict[str: List[int]]): (band, list of night relative to peak you want to obtain a magnitude for) pair for each band in survey
         sed_filename (str): ignored
         cosmo (astropy.cosmology): ignored
 
@@ -1643,7 +1801,7 @@ <h2 id="returns">Returns</h2>
           - &#39;obj_type&#39; contains a string for the type of object. Will always be &#39;VariableNoise&#39; here
           - &#39;sed&#39; contains the filename of the sed used. Will always be &#39;VariableNoise&#39; here              
     &#34;&#34;&#34;
-    noiseless_lc_dict = self.gen_variable(redshift, nites)
+    noiseless_lc_dict = self.gen_variable(redshift, nite_dict)
     noise = np.random.normal(loc=0, scale=0.25, size=noiseless_lc_dict[&#39;lc&#39;].shape[0])
     noiseless_lc_dict[&#39;lc&#39;][&#39;MAG&#39;] = noiseless_lc_dict[&#39;lc&#39;][&#39;MAG&#39;].values + noise
     noiseless_lc_dict[&#39;obj_type&#39;] = &#39;VariableNoise&#39;
diff --git a/docs/utils.html b/docs/utils.html
index 85a1a3b..0328001 100644
--- a/docs/utils.html
+++ b/docs/utils.html
@@ -31,6 +31,7 @@ <h1 class="title">Module <code>deeplenstronomy.utils</code></h1>
 
 import os
 import sys
+import yaml
 
 from astropy.io import fits
 import numpy as np
@@ -331,7 +332,26 @@ <h1 class="title">Module <code>deeplenstronomy.utils</code></h1>
         image_indices = np.argmin(np.sum(np.abs(im_param_array - map_param_array) / im_stds, axis=2), axis=0)
 
     return image_indices
-    </code></pre>
+    
+
+def read_cadence_file(filename):
+    &#34;&#34;&#34;
+    Parse a cadence file.
+
+    Args:
+        filename (str): Name of cadence file
+
+    Returns:
+        cadence_dict: dictionary containing cadence file contents
+    &#34;&#34;&#34;
+    with open(filename, &#39;r&#39;) as f:
+        cadence_dict = yaml.safe_load(f)        
+        
+        # Set reference mjd to the default value of 0
+        if &#39;REFERENCE_MJD&#39; not in cadence_dict:
+            cadence_dict[&#39;REFERENCE_MJD&#39;] = 0
+                        
+    return cadence_dict</code></pre>
 </details>
 </section>
 <section>
@@ -589,6 +609,45 @@ <h2 id="returns">Returns</h2>
     return image_indices</code></pre>
 </details>
 </dd>
+<dt id="deeplenstronomy.utils.read_cadence_file"><code class="name flex">
+<span>def <span class="ident">read_cadence_file</span></span>(<span>filename)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Parse a cadence file.</p>
+<h2 id="args">Args</h2>
+<dl>
+<dt><strong><code>filename</code></strong> :&ensp;<code>str</code></dt>
+<dd>Name of cadence file</dd>
+</dl>
+<h2 id="returns">Returns</h2>
+<dl>
+<dt><code>cadence_dict</code></dt>
+<dd>dictionary containing cadence file contents</dd>
+</dl></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def read_cadence_file(filename):
+    &#34;&#34;&#34;
+    Parse a cadence file.
+
+    Args:
+        filename (str): Name of cadence file
+
+    Returns:
+        cadence_dict: dictionary containing cadence file contents
+    &#34;&#34;&#34;
+    with open(filename, &#39;r&#39;) as f:
+        cadence_dict = yaml.safe_load(f)        
+        
+        # Set reference mjd to the default value of 0
+        if &#39;REFERENCE_MJD&#39; not in cadence_dict:
+            cadence_dict[&#39;REFERENCE_MJD&#39;] = 0
+                        
+    return cadence_dict</code></pre>
+</details>
+</dd>
 <dt id="deeplenstronomy.utils.read_distribution_file"><code class="name flex">
 <span>def <span class="ident">read_distribution_file</span></span>(<span>filename)</span>
 </code></dt>
@@ -871,6 +930,7 @@ <h1>Index</h1>
 <li><code><a title="deeplenstronomy.utils.dict_select_choose" href="#deeplenstronomy.utils.dict_select_choose">dict_select_choose</a></code></li>
 <li><code><a title="deeplenstronomy.utils.draw_from_user_dist" href="#deeplenstronomy.utils.draw_from_user_dist">draw_from_user_dist</a></code></li>
 <li><code><a title="deeplenstronomy.utils.organize_image_backgrounds" href="#deeplenstronomy.utils.organize_image_backgrounds">organize_image_backgrounds</a></code></li>
+<li><code><a title="deeplenstronomy.utils.read_cadence_file" href="#deeplenstronomy.utils.read_cadence_file">read_cadence_file</a></code></li>
 <li><code><a title="deeplenstronomy.utils.read_distribution_file" href="#deeplenstronomy.utils.read_distribution_file">read_distribution_file</a></code></li>
 <li><code><a title="deeplenstronomy.utils.read_images" href="#deeplenstronomy.utils.read_images">read_images</a></code></li>
 <li><code><a title="deeplenstronomy.utils.select_params" href="#deeplenstronomy.utils.select_params">select_params</a></code></li>
diff --git a/docs/visualize.html b/docs/visualize.html
index f72813e..18e56e1 100644
--- a/docs/visualize.html
+++ b/docs/visualize.html
@@ -32,6 +32,7 @@ <h1 class="title">Module <code>deeplenstronomy.visualize</code></h1>
 from astropy.visualization import make_lupton_rgb
 import matplotlib.pyplot as plt
 import numpy as np
+import pandas as pd
 
 def _no_stretch(val):
     return val
@@ -92,7 +93,58 @@ <h1 class="title">Module <code>deeplenstronomy.visualize</code></h1>
     plt.show(block=True)
     plt.close()
 
-    return</code></pre>
+    return
+
+def view_corner(metadata, labels, hist_kwargs={}, hist2d_kwargs={}, label_kwargs={}):
+    &#34;&#34;&#34;
+    Show a corner plot of the columns in a DataFrame.
+    
+    Args:
+        metadata (pd.DataFrame): A pandas DataFrame containing the metadata to visualize
+        labels (dict): A dictionary mapping column names to axis labels 
+        hist_kwargs (dict): keyword arguments to pass to matplotlib.pyplot.hist
+        hist2d_kwargs (dict): keyword arguments to pass to matplotlib.pyplot.hist2d
+        label_kwargs (dict): keyword arguments to pass to matplotlib.axes.Axes.set_xlabel (and ylabel)
+        
+    Raises:
+        KeyError: if one or more of the columns are not present in the metadata
+        TypeError: if metadata is not a pandas DataFrame
+        TypeError: if labels is not a dict
+    &#34;&#34;&#34;
+    if not isinstance(metadata, pd.DataFrame):
+        raise TypeError(&#34;first argument must be a pandas DataFrame&#34;)
+        
+    if not isinstance(labels, dict):
+        raise TypeError(&#34;second argument must be a list&#34;)
+    
+    if any([x not in metadata.columns for x in labels]):
+        raise KeyError(&#34;One or more passed columns is not present in the metadata&#34;)
+    
+    fig, axs = plt.subplots(len(labels), len(labels), figsize=(14,14))
+
+    for row, row_label in enumerate(labels.keys()):
+        for col, col_label in enumerate(labels.keys()):
+
+            if row == col:
+                # hist
+                axs[row, col].hist(metadata[row_label].values, **hist_kwargs)
+
+            elif row &gt; col:
+                # hist2d
+                axs[row, col].hist2d(metadata[col_label].values, 
+                                     metadata[row_label].values, **hist2d_kwargs)
+            else:
+                axs[row, col].set_visible(False)
+
+            if row == len(labels) -1:
+                axs[row, col].set_xlabel(labels[col_label], **label_kwargs)
+
+            if col == 0 and row != 0:
+                axs[row, col].set_ylabel(labels[row_label], **label_kwargs)
+
+    fig.tight_layout()
+    plt.show()
+    plt.close()</code></pre>
 </details>
 </section>
 <section>
@@ -102,6 +154,89 @@ <h1 class="title">Module <code>deeplenstronomy.visualize</code></h1>
 <section>
 <h2 class="section-title" id="header-functions">Functions</h2>
 <dl>
+<dt id="deeplenstronomy.visualize.view_corner"><code class="name flex">
+<span>def <span class="ident">view_corner</span></span>(<span>metadata, labels, hist_kwargs={}, hist2d_kwargs={}, label_kwargs={})</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Show a corner plot of the columns in a DataFrame.</p>
+<h2 id="args">Args</h2>
+<dl>
+<dt><strong><code>metadata</code></strong> :&ensp;<code>pd.DataFrame</code></dt>
+<dd>A pandas DataFrame containing the metadata to visualize</dd>
+<dt><strong><code>labels</code></strong> :&ensp;<code>dict</code></dt>
+<dd>A dictionary mapping column names to axis labels </dd>
+<dt><strong><code>hist_kwargs</code></strong> :&ensp;<code>dict</code></dt>
+<dd>keyword arguments to pass to matplotlib.pyplot.hist</dd>
+<dt><strong><code>hist2d_kwargs</code></strong> :&ensp;<code>dict</code></dt>
+<dd>keyword arguments to pass to matplotlib.pyplot.hist2d</dd>
+<dt><strong><code>label_kwargs</code></strong> :&ensp;<code>dict</code></dt>
+<dd>keyword arguments to pass to matplotlib.axes.Axes.set_xlabel (and ylabel)</dd>
+</dl>
+<h2 id="raises">Raises</h2>
+<dl>
+<dt><code>KeyError</code></dt>
+<dd>if one or more of the columns are not present in the metadata</dd>
+<dt><code>TypeError</code></dt>
+<dd>if metadata is not a pandas DataFrame</dd>
+<dt><code>TypeError</code></dt>
+<dd>if labels is not a dict</dd>
+</dl></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def view_corner(metadata, labels, hist_kwargs={}, hist2d_kwargs={}, label_kwargs={}):
+    &#34;&#34;&#34;
+    Show a corner plot of the columns in a DataFrame.
+    
+    Args:
+        metadata (pd.DataFrame): A pandas DataFrame containing the metadata to visualize
+        labels (dict): A dictionary mapping column names to axis labels 
+        hist_kwargs (dict): keyword arguments to pass to matplotlib.pyplot.hist
+        hist2d_kwargs (dict): keyword arguments to pass to matplotlib.pyplot.hist2d
+        label_kwargs (dict): keyword arguments to pass to matplotlib.axes.Axes.set_xlabel (and ylabel)
+        
+    Raises:
+        KeyError: if one or more of the columns are not present in the metadata
+        TypeError: if metadata is not a pandas DataFrame
+        TypeError: if labels is not a dict
+    &#34;&#34;&#34;
+    if not isinstance(metadata, pd.DataFrame):
+        raise TypeError(&#34;first argument must be a pandas DataFrame&#34;)
+        
+    if not isinstance(labels, dict):
+        raise TypeError(&#34;second argument must be a list&#34;)
+    
+    if any([x not in metadata.columns for x in labels]):
+        raise KeyError(&#34;One or more passed columns is not present in the metadata&#34;)
+    
+    fig, axs = plt.subplots(len(labels), len(labels), figsize=(14,14))
+
+    for row, row_label in enumerate(labels.keys()):
+        for col, col_label in enumerate(labels.keys()):
+
+            if row == col:
+                # hist
+                axs[row, col].hist(metadata[row_label].values, **hist_kwargs)
+
+            elif row &gt; col:
+                # hist2d
+                axs[row, col].hist2d(metadata[col_label].values, 
+                                     metadata[row_label].values, **hist2d_kwargs)
+            else:
+                axs[row, col].set_visible(False)
+
+            if row == len(labels) -1:
+                axs[row, col].set_xlabel(labels[col_label], **label_kwargs)
+
+            if col == 0 and row != 0:
+                axs[row, col].set_ylabel(labels[row_label], **label_kwargs)
+
+    fig.tight_layout()
+    plt.show()
+    plt.close()</code></pre>
+</details>
+</dd>
 <dt id="deeplenstronomy.visualize.view_image"><code class="name flex">
 <span>def <span class="ident">view_image</span></span>(<span>image, stretch_func=&lt;function _no_stretch&gt;, **imshow_kwargs)</span>
 </code></dt>
@@ -215,6 +350,7 @@ <h1>Index</h1>
 </li>
 <li><h3><a href="#header-functions">Functions</a></h3>
 <ul class="">
+<li><code><a title="deeplenstronomy.visualize.view_corner" href="#deeplenstronomy.visualize.view_corner">view_corner</a></code></li>
 <li><code><a title="deeplenstronomy.visualize.view_image" href="#deeplenstronomy.visualize.view_image">view_image</a></code></li>
 <li><code><a title="deeplenstronomy.visualize.view_image_rgb" href="#deeplenstronomy.visualize.view_image_rgb">view_image_rgb</a></code></li>
 </ul>